Set集合 哈希值 Set集合存儲元素不重覆的原理 Set集合在調用add方法的時候,add方法會調用元素的hashCode方法和equals方法,判斷元素是否重覆,若hashCode和equals都相同則不添加到集合,要保證hashCode和equals不同必須重寫hashCode和equals方 ...
Set集合
import java.util.*;
public class HashSetDemo{
public static void main(String[] args){
//Set介面的特點
//是一個沒有索引的集合,不允許存儲重覆的元素
//HashSet繼承自Set介面
Set<String> aSet = new HashSet<String>();
//Set介面也是繼承自Collection介面,所以也繼承了他的方法
aSet.add("李白");
aSet.add("杜甫");
aSet.add("蘇軾");
aSet.add("辛棄疾");
aSet.add("辛棄疾");
System.out.println(aSet);//[辛棄疾, 李白, 杜甫, 蘇軾],輸出結果為無序,不可以重覆這個就是HashSet集合的特點
//沒有索引,索引不能用for迴圈遍歷
//遍歷的話,可以使用迭代器iterator,調用Collection的方法iterator,將會返回一個迭代器
Iterator<String> iterator = aSet.iterator();
//使用迭代器Iterator的方法hasNext,和next遍歷集合
while(iterator.hasNext()){
String str = iterator.next();
System.out.println(str);
}
System.out.println("=========================");
//增強for迴圈遍歷
for(String str1 :aSet){
System.out.println(str1);
}
}
}
哈希值
public class Person{
}
//哈希值:是一個十進位的整數,有系統隨機給出
//是一個對象地址值,是一個邏輯地址,是模擬出來得到
//的地址,不是數據實際存儲的物理地址
//在Object類中有一個方法,可以獲取對象的哈希值
public class HashCodeDemo{
public static void main(String[] args){
Person p1 = new Person();
//調用HashCode的方法,將會返回一個哈希值
int hashCode = p1.hashCode();
System.out.println(hashCode);//991505714
}
}
Set集合存儲元素不重覆的原理
Set集合在調用add方法的時候,add方法會調用元素的hashCode方法和equals方法,判斷元素是否重覆,若hashCode和equals都相同則不添加到集合,要保證hashCode和equals不同必須重寫hashCode和equals方法
LinkedHashSet
import java.util.*;
public class LinkedHashSetDemo{
public static void main(String[] args){
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("李白");
linkedHashSet.add("蘇軾");
linkedHashSet.add("李清照");
linkedHashSet.add("杜甫");
linkedHashSet.add("李白");
System.out.println(linkedHashSet);//[李白,蘇軾, 李清照, 杜甫],有序,不重覆
}
}
可變參數
//可變參數原理,可變參數底層就是一個數組,根據傳遞//參數個數不同,會創建不同的長度的數組
public class VarArgsDemo{
public static void main(String[] args){
int num = method(1,2,3,4,5);
System.out.println(num);
}
public static int method(int...arr){
int sum = 0;
for(int i=0;i<arr.length;i++){
sum = sum+arr[i];
}
return sum;
}
}
Collections集合工具類對集合進行操作
import java.util.*;
public class CollectionsDemo{
public static void main(String[] args){
ArrayList<Integer> arraylist = new ArrayList<>();
//addAll往集合中添加元素,靜態方法,直接調用
Collections.addAll(arraylist,1,2,3,4,5);
System.out.println(arraylist);
}
}
public class Person implements Comparable<Person>{
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name=name;
this.age=age;
}
//重寫toString,輸出對象時會調用toStirng的方法
public String toString(){
String str = "name="+name+" age="+age;
return str;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
//重寫compareTo方法
public int compareTo(Person o){
//Comparable介面的排序規則,自己-參數,為升序
return this.getAge()-o.getAge();
}
}
import java.util.*;
//對集合進行排序
public class SortDemo{
public static void main(String[] args){
ArrayList<Integer> list = new ArrayList<>();
list.add(4);
list.add(2);
list.add(3);
list.add(1);
//使用Collections的sort方法,排序
Collections.sort(list);
System.out.println(list);
//怎麼樣對對象進行排序
//對對象進行排序需要對象實現一個介面Comparable
//並且重寫介面中的方法compareTo定義排序的規則
Person p1 = new Person("李白",22);
Person p2 = new Person("杜甫",23);
Person p3 = new Person("李清照",18);
ArrayList<Person> list1 = new ArrayList<>();
list1.add(p1);
list1.add(p2);
list1.add(p3);
System.out.println(list1);
//對Person按照年齡進行排序
Collections.sort(list1);
System.out.println(list1);//[name=李清照 age=18, name=李白 age=22, name=杜甫 age=23]
}
}
Map集合
Map集合的提點:
Map集合時一個雙列集合Map<k,v>
Map集合中的元素,key和value的數據類型可以相同,也可以不同
Map'集合中的元素,key時不允許重覆的,value時可以重覆的
Map集合中的元素,key和value時一一對應的
常用的Map集合的實現類
HashMap集合:
HashMap集合實現了Map介面
- HashMap集合底層時哈希表,查詢的速度特別的快
- HashMap集合是一個無序的集合
LinkedHashMap集合
LinkedHashMap集合繼承了HashMap集合
查詢速度快
有序的集合
Map介面中的常用方法
import java.util.*;
//Map集合常用的方法
public class MapDemo{
public static void main(String[] args){
//使用Map集合的實現類HashMap來創建多態
Map<String,String> aMap = new HashMap<>();
//向集合中添加鍵值對的方法put
aMap.put("周瑜","小喬");
aMap.put("孫策","大喬");
aMap.put("呂布","貂蟬");
System.out.println(aMap);//呂布=貂蟬, 孫策=大喬, 周瑜=小喬}
//Map集合中不允許存儲重覆的key,如果重覆了話,會把後來的key的value替換原來的value
aMap.put("呂布","西施");
System.out.println(aMap);//呂布=西施, 孫策=大喬, 周瑜=小喬}
System.out.println("=========手動分割線==========");
//get方法,會根據指定的鍵,獲取對應的值
String str = aMap.get("周瑜");
System.out.println(str);//小喬
//containsKey();判斷集合中是否包含指定的鍵,返回boolean
boolean b = aMap.containsKey("呂布");
System.out.println(b);//true
//remove;把指定的鍵所對應的鍵值對元素,刪除掉,返回被刪除元素的值
String str2 = aMap.remove("呂布");
System.out.println(str2);//西施
System.out.println(aMap);//{孫策=大喬, 周瑜=小喬}
}
}
Map遍歷建找值
import java.util.*;
public class KeySetDemo{
public static void main(String[] args){
Map<String,Integer> aMap = new HashMap<>();
aMap.put("大喬",22);
aMap.put("小喬",20);
aMap.put("王昭君",24);
aMap.put("楊玉環",26);
//遍歷集合的第一種方式通過Map集合中的keySet方法獲得一個包含所有key的Set集合
Set<String> aSet =aMap.keySet();
//獲取迭代器
Iterator<String> iterator = aSet.iterator();
//先判斷有沒有下一個元素,然後獲取出Key
while(iterator.hasNext()){
String aKey = iterator.next();
Integer aInteger = aMap.get(aKey);
System.out.println(aKey+"-"+aInteger);
}
System.out.println("手動分割線");
//增強for第二章遍歷方式
for(String bKey:aSet){
Integer bInteger = aMap.get(bKey);
System.out.println(bKey+"-"+bInteger);
}
//第三種方式使用Entry對象遍歷
//實現步驟
/*
1.使用Map集合中的方法entrySet(),把集合中多個Entry(鍵值對)對象取出來,存到一個Set集合中
2.遍歷Set集合,獲取每一個對象
3.使用Entry對象中的方法getKey()和getValue()獲取鍵與值
*/
System.out.println("=============");
Set<Map.Entry<String,Integer>> set = aMap.entrySet();
//增強for
for(Map.Entry<String,Integer> entry : set){
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"-"+value);
}
}
}
package demo14;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package demo14;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class PersonDemo {
public static void main(String[] args) {
show1();
}
private static void show1(){
//要保證存起來的key唯一,必須重寫hashCode和equals方法
HashMap<Person,String > map = new HashMap<>();
map.put(new Person("女王",18),"英國");
map.put(new Person("秦始王",19),"秦國");
map.put(new Person("普京",18),"俄羅斯");
map.put(new Person("女王",18),"美國");
Set<Map.Entry<Person,String >> set = map.entrySet();
for(Map.Entry<Person,String > entry:set){
Person key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"--"+value);
}
}
private static void show() {
HashMap<String,Person> map = new HashMap<>();
map.put("北京",new Person("張三",18));
map.put("上海",new Person("李四",19));
map.put("廣州",new Person("王五",20));
map.put("北京",new Person("趙六",18));
Set<String> set = map.keySet();
for(String key :set){
Person value = map.get(key);
System.out.println(key+"--"+value);
}
}
}
LinkedHashMap集合
package demo14;
import java.util.HashMap;
import java.util.LinkedHashMap;
//LinkedHashMap繼承自HashMap
public class LinkedHashMapDemo {
public static void main(String[] args) {
//是一個有序的集合
HashMap<String,String> map = new LinkedHashMap<>();
map.put("a","a");
map.put("c","c");
map.put("d","d");
map.put("a","b");
System.out.println(map);//{a=b, c=c, d=d},有序,不重覆
}
}
Hashtable集合
Hashtable集合繼承自Map介面
Hashtable不能夠存儲Null鍵null值,現在這個集合已經被淘汰了,但是他的子類Properties集合依然活躍,是一個和IO流相結合的集合