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流相结合的集合
