关于JAVA集合的学习
1、集合概述
1.1、什么是集合？有什么用？
数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。
集合为什么说在开发中使用较多？
集合是一个容器，是一个载体，可以一次容纳多个对象。
在实际开发中，假设连接数据库，数据库当中有10条记录，
那么假设把这10条记录查询出来，在java程序中会将10条
数据封装成10个java对象，然后将10个java对象放到某一个
集合当中，将集合传到前端，然后遍历集合，将一个数据一个
数据展现出来。
1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，
集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
list.add(100); //自动装箱Integer
注意：
集合在java中本身是一个容器，是一个对象。
集合中任何时候存储的都是“引用”。
1.3、在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。
什么是数据结构？
数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。例如：
数组、二叉树、链表、哈希表...
以上这些都是常见的数据结构。
你往集合c1中放数据，可能是放到数组上了。
你往集合c2中放数据，可能是放到二叉树上了。
.....
你使用不同的集合等同于使用了不同的数据结构。
你在java集合这一章节，你需要掌握的不是精通数据结构。java中已经将数据结构
实现了，已经写好了这些常用的集合类，你只需要掌握怎么用？在什么情况下选择
哪一种合适的集合去使用即可。
new ArrayList(); 创建一个集合，底层是数组。
new LinkedList(); 创建一个集合对象，底层是链表。
new TreeSet(); 创建一个集合对象，底层是二叉树。
.....
1.4、集合在java JDK中哪个包下？
java.util.*;
所有的集合类和集合接口都在java.util包下。
1.5、为了让大家掌握集合这块的内容，最好能将集合的继承结构图背会！！！
集合整个这个体系是怎样的一个结构，你需要有印象。
1.6、在java中集合分为两大类：
一类是单个方式存储元素：
单个方式存储元素，这一类集合中超级父接口：java.util.Collection;
一类是以键值对儿的方式存储元素
以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;
2、总结重点：
第一个重点：把集合继承结构图背会。
第二个重点：把Collection接口中常用方法测试几遍。
一.Collection
1 /** 2 * 关于java.util.collection 接口常用的方法 3 * 1.Collecton 中存放的元素 4 * 没有使用泛型,可以存储object的所有子类 5 * 6 * @author ASUS 7 * 常用方法: 8 * boolean add(object e) 给集合添加元素 9 * int size() 获取集合个数 10 * void clear() 清除集合元素 11 * boolean contains(Object o) [判断当前集合是否包含某元素 12 * boolean remove(object o) 删除集合中的某个元素 13 * boolean isEmpty() 判断集合是否为空 14 * Object toArray() 集合转化为数组 15 * 16 * 17 */
第三个重点：把迭代器弄明白。
第四个重点：Collection接口中的remove方法和contains方法底层都会调用equals，
这个弄明白。
迭代器
1 package javase.collection; 2 3 import java.util.Collection; 4 import java.util.HashSet; 5 import java.util.Iterator; 6 7 /** 8 * 关于集合迭代器的学习 9 * 注意:在所有collection集合通用的一种方式,Map中不能用 10 * 放在集合里的元素比较的是equal方法,没有重写equal放法的话,比较的是内存地址,重写之后比较的是内容是否相等 11 * remove()方法执行时也会调用equal方法,重写了equal方法后,比较的是内容,会一块删除 12 * @author ASUS 13 * 14 */ 15 public class CollectionTest02 { 16 17 public static void main(String[] args) { 18 //创建集合 19 Collection c=new HashSet(); 20 //添加元素 21 c.add("abc"); 22 c.add(1234); 23 c.add("def"); 24 c.add(123); 25 //对集合的元素进行遍历/迭代 26 //第一步:获得集合对象的迭代器对象 27 Iterator it = c.iterator(); 28 //第二步:通过以上迭代器对对象进行迭代/遍历集合 29 /* 30 * 以下两个方法是迭代器对象Iterator的方法 31 * boolean hasNext() 如果仍有元素可以迭代,返回true 32 * Object next() 返回迭代的下一个元素 33 * 34 */ 35 //不管你存进去的是什么,拿出来的一般都是Object 36 while(it.hasNext()){ 37 38 39 Object obj=it.next(); 40 //存入的是什么类型,取出的就是什么类型,只是在输出的时候调用toString方法,会转换成字符串 41 if(obj instanceof Integer){ 42 System.out.println("Integer类型"); 43 44 } 45 System.out.println(obj); 46 } 47 48 } 49 50 }
关于迭代器的再次说明
1 package javase.collection; 2 3 import java.sql.Connection; 4 import java.util.ArrayList; 5 import java.util.Collection; 6 import java.util.Iterator; 7 8 /** 9 * 关于迭代器的再次说明 10 * @author ASUS 11 * 12 * 13 * 14 */ 15 public class CollectionTest03 { 16 public static void main(String[] args) { 17 Collection c=new ArrayList(); 18 /* 19 * 注意:此时获取的迭代器,指向的是 集合中没有元素状态下的迭代器 20 *一定要注意:集合结构发生改变,迭代器必须重新获取 21 *当集合结构发生了改变,迭代器没有重新获取时,调用next()方法,出现 java.util.ConcurrentModificationException 22 出现异常的原因:集合中的元素删除了,但没有通知迭代器,迭代器不知道所以报异常 23 * 在迭代过程中,不能remove其中的元素 24 */ 25 //Iterator it = c.iterator(); 26 c.add(1); 27 c.add(2); 28 c.add(3); 29 c.add(4); 30 c.add(5); 31 32 Iterator it = c.iterator(); 33 while (it.hasNext()){ 34 Object obj = it.next(); 35 //删除元素,集合结构发生变化 应重新获取迭代器,但循环没有重新获取迭代器 36 //会出现异常java.util.ConcurrentModificationException 37 //c.remove(obj); 38 it.remove(); //删除的一定是迭代器当前指向的元素 39 System.out.println(obj); 40 } 41 System.out.println(c.size()); 42 } 43 }
1、List接口中的常用方法。
List是Collection接口的子接口。所以List接口中有一些特有的方法。
void add(int index, Object element)
Object set(int index, Object element)
Object get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
Object remove(int index)
2、迭代器迭代元素的过程中不能使用集合对象的remove方法删除元素，
要使用迭代器Iterator的remove方法来删除元素，防止出现异常：
ConcurrentModificationException
3、ArrayList
ArrayList集合初始化容量10
扩容为原容量1.5倍。
底层是数组。
数组优点和缺点要能够说出来！
另外要注意：ArrayList集合末尾增删元素效率还是可以的。
1 package javase.collection; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 import java.util.List; 6 7 /** 8 * x学习Collection集合的List集合 9 * @author yumu 10 * 1.List集合特点:有序性(有下标),可重复性 11 * 2.List集合特有的常见的方法 12 * void add(int index,E element) 集合指定位置添加元素 13 * E get(int index) 根据下标取元素 14 * int indexOf(Object o) 指定元素前面加数据 15 * int lastIndexOf(Object o) 指定元素后面加元素 16 * E remove(int index) 删除指定元素 17 * E set(int index,E element) 根据下标修改元素 18 * 19 * 20 * 3.ArrayList 初始化容量为10,扩容,增长到原来容量的1.5倍 21 * 22 * 23 * 4.数组优点:检索效率高 24 * 5.数组缺点:随机增删元素效率较低,数组无法存储大数据量,很难找到大的连续的存储空间 25 * 向数组末尾增加元素,效率很高,不受影响 26 * 27 * 6.面试题:这么多集合,你平时用的最多的是哪一个? 28 * ArrayList集合,往末尾加元素,效率不受影响, 29 * 7.ArrayList非线程安全 30 * 31 * 32 * LinkedList 集合 33 * LinkedList 没有初始化容量 34 * 最初这个链表没有任何元素,first和 last都是null 35 * 不管是LinkedList 还是ArrayList ,以后写代码不需要关心具体是哪个集合 36 * 因为我们要面向接口编程,调用的方法都是接口的方法 37 * 38 * 39 */ 40 public class ListTest01 { 41 public static void main(String[] args) { 42 List l=new ArrayList(); 43 44 l.add("A"); 45 l.add("B"); 46 l.add("C"); 47 l.add("D"); 48 l.add("E"); 49 l.add("E"); 51 52 //在列表指定位置插入第一个元素(第一个参数是下标) 53 l.add(1, "H"); 54 55 Object obj1 = l.get(2); 56 System.out.println(obj1); 57 System.out.println("----------"); 58 59 Iterator it = l.iterator(); 60 while (it.hasNext()){ 61 Object obj = it.next(); 62 System.out.println(obj); 63 } 64 System.out.println("----------"); 65 //list集合特有的遍历方式 因为有get 66 for(int i=0;i<l.size();i++){ 67 Object obj = l.get(i); 68 System.out.println(obj); 69 } 70 71 } 72 73 }
4、链表数据结构
第一：单向链表和双向链表数据结构要理解。
第二：链表数据结构的优点和缺点要能够说出来。
5、Vector：
Vector初始化容量是10.
扩容为原容量的2倍。
底层是数组。
Vector底层是线程安全的。 带有synchronized关键字
1 package javase.collection; 2 3 import java.util.Iterator; 4 import java.util.List; 5 import java.util.Vector; 6 7 /** 8 * VectorList集合 9 * @author ASUS 10 * 11 *1.底层是一个数组 12 *2.初始化容量是10 13 *3.怎么扩容 14 * 10--->20--->40 15 *4.ArrayList集合扩容特点 16 * 是原容量的1.5倍 17 *5.Vector中的所有方法都是线程同步的,都带有synchronized关键字 18 * 是线程安全的,效率比较低,使用较少 19 *6.怎么讲一个线程不安全的ArrayList集合转换成线程安全的? 20 * 使用集合工具类 21 * Java.util.collections; 集合工具类 22 * java.util.collection 是集合接口 23 */ 24 public class VectorTest { 25 public static void main(String[] args) { 26 27 28 //创建 采用多态 29 List vector = new Vector(); 30 //Vector vector =new Vector(); 31 vector.add(1); 32 vector.add(2); 33 vector.add(3); 34 vector.add(4); 35 vector.add(5); 36 vector.add(6); 37 vector.add(7); 38 vector.add(8); 39 vector.add(9); 40 vector.add(10); 41 vector.add(11); 42 //遍历 43 Iterator it=vector.iterator(); 44 while(it.hasNext()){ 45 System.out.println(it.next()); 46 } 47 } 52 53 }
怎么得到一个线程安全的List：
Collections.synchronizedList(list);
1 package javase.collection; 2 3 import java.util.ArrayList; 4 import java.util.Collections; 5 import java.util.HashSet; 6 import java.util.List; 7 import java.util.Set; 8 9 /*8 10 * 集合工具类 11 * 12 * java.util.Collection 集合接口 13 * java.util.Collections 集合工具类 14 * 15 */ 16 public class CollectionsTest { 17 18 public static void main(String[] args) { 19 //ArrayList集合不是线程安全的 20 List<String> list=new ArrayList<>(); 21 //变成线程安全的 22 Collections.synchronizedList(list); 23 24 //排序 25 list.add("avju"); 26 list.add("abc"); 27 list.add("def"); 28 list.add("ghj"); 29 list.add("xyz"); 30 31 //sort 排序 32 Collections.sort(list); 33 for(String s:list){ 34 System.out.println(s); 35 } 36 List<wugui2> wuguis=new ArrayList<>(); 37 38 wuguis.add(new wugui2(123314)); 39 wuguis.add(new wugui2(23314)); 40 wuguis.add(new wugui2(3314)); 41 wuguis.add(new wugui2(43241)); 42 43 //对List集合元素排序,需要集合实现Comparable接口 44 Collections.sort(wuguis); 45 for(wugui2 wg:wuguis){ 46 System.out.println(wg); 47 } 48 System.out.println("------"); 49 50 //对set集合怎么排序 51 Set<String> set=new HashSet<>(); 52 set.add("abc"); 53 set.add("def"); 54 set.add("ghj"); 55 set.add("xyz"); 56 //将Set集合转换为List 57 List<String> list2=new ArrayList<String>(set); 58 Collections.sort(list2); 59 for(String sc:list2){ 60 System.out.println(sc); 61 } 65 } 66 67 } 68 class wugui2 implements Comparable<wugui2>{ 69 int age; 70 71 public wugui2(int age) { 72 super(); 73 this.age = age; 74 } 75 76 @Override 77 public String toString() { 78 79 return "乌龟{"+"age="+age+'}'; 80 } 81 82 83 @Override 84 public int compareTo(wugui2 o) { 85 86 return this.age-o.age; 87 } 88 89 }
6、JDK5.0新特性：泛型
第一：集合使用泛型来减少向下转型的操作。
第二：怎么使用泛型？
第三：怎么自定义泛型？
1 package javase.collection; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 import java.util.List; 6 7 /** 8 * 泛型 9 * @author ASUS 10 *1.JDK5.0之后的新特征 11 *2.泛型这种语法机制,只在程序编译阶段起作用,只给编译器参考的(运行阶段没用) 12 *3.好处:集合存储元素统一了 13 *4.缺点:集合元素缺乏多样性 14 * 15 *JDK8.0之后,自动类型推断机制 16 * ArrayList<这里的类型会自动推断> 17 *自定义泛型: 18 * <>里面是一个标识符,随便写 19 * java源代码中经常出现的是 20 * <E> 元素 Element单词首字母 21 * <T> Type单词首字母 22 * 23 */ 24 public class GenericTest01 { 25 26 public static void main(String[] args) { 27 //自动类型推断 28 List<Animal> mylist=new ArrayList<>(); 29 //添加泛型 30 //List<Animal> mylist=new ArrayList<Animal>(); 31 32 33 mylist.add(new Cat()); 34 mylist.add(new Dog()); 35 mylist.add(new Animal()); 36 37 Cat c =new Cat(); 38 Dog d=new Dog(); 39 //通过泛型只能添加Animal类型 40 mylist.add(c); 41 mylist.add(d); 42 43 Iterator<Animal> it=mylist.iterator(); 44 while(it.hasNext()){ 45 Animal a = it.next(); 46 a.move(); 47 //添加泛型后,如果要调用子类特有的方法,依旧需要强转 48 if(a instanceof Cat){ 49 Cat c1=(Cat)a; 50 c1.eatchMouse(); 51 }else if(a instanceof Dog){ 52 Dog d1=(Dog)a; 53 d1.seeFamily(); 54 } 55 } 56 57 58 // 59 List<String> strlist=new ArrayList(); 60 strlist.add("http://www.baidu.com"); 61 strlist.add("http://www.jingdong.com"); 62 strlist.add("http://www.alibaba.com"); 63 64 65 Iterator<String> it2 = strlist.iterator(); 66 while(it2.hasNext()){ 67 String s = it2.next(); 68 //因为使用了泛型 s才能调用subString方法 Iterator 为object类型的 69 70 String substring = s.substring(7); 71 System.out.println(substring); 72 } 73 } 74 75 } 76 class Animal{ 77 public void move() { 78 System.out.println("动物移动"); 79 } 80 81 } 82 class Cat extends Animal{ 83 public void eatchMouse(){ 84 System.out.println("猫吃老鼠"); 85 86 } 87 } 88 class Dog extends Animal{ 89 public void seeFamily(){ 90 System.out.println("狗看家"); 91 92 } 93 }
7、JDK5.0新特性：
foreach
对数组怎么遍历？
for(int i : arr){
System.out.println(i);
}
对集合怎么遍历？
for(String s : list){
System.out.println(s);
}
8、JDK8新特性：钻石表达式
List<String> list = new ArrayList<>();
类型自动推断！
二,map
1、掌握Map接口中常用方法。
2、遍历Map集合的两种方式都要精通。
第一种：获取所有key，遍历每个key，通过key获取value.
第二种：获取Set<Map.Entry>即可，遍历Set集合中的Entry
调用entry.getKey() entry.getValue()
1 package javase.map; 2 3 import java.util.HashMap; 4 import java.util.Iterator; 5 import java.util.Map; 6 import java.util.Map.Entry; 7 import java.util.Set; 8 9 /** 10 * java .util.Map接口常用的方法 11 * @author ASUS 12 * 1.Map集合以Key 和value 方式存储数据:键值对 13 * key和value都是引用数据类型 14 * key和value都是存储对象的内存地址 15 * key起到主导作用,value是key的附属品 16 * 2.Map和collection没有继承guanix 17 * 3.Map常用方法: 18 * V put(K key ,V value) 向集合添加键值对 19 * V get(Object key) 通过key 获取 value 20 * v get clear() 清空map集合 21 * boolean containkey() 判断包含哪个key 22 * boolean containValue() 判断集合中包含哪个value 23 * boolean isEmpty() 判断map集合元素个数是否为空 24 * set<k> keySet() 获取Map集合所有的key (所有的键是一个set集合) 25 * V remove() 26 * int size() 27 * Collection<V> values() 获取Map集合所有的value,返回一个Collection 28 * Set<Map.Entry<K,V>> entrySet() 将Map集合转换为set集合 29 * 1="张三" 30 * 31 */ 32 public class MapTest01 { 33 34 /* 35 * map集合的遍历 36 */ 37 public static void main(String[] args) { 38 //第一种方式 :获取所有的key,通过遍历key 来遍历value 39 Map<Integer, String> map=new HashMap<>(); 40 map.put(1, "张三"); 41 map.put(2, "李四"); 42 map.put(3, "王五"); 43 map.put(5, "赵六"); 44 map.put(4, "马奇"); 45 //遍历Map集合 46 //获取所有的key 47 Set<Integer> keys = map.keySet(); 48 //遍历key 所有key是一个set集合 49 Iterator<Integer> it = keys.iterator(); 50 while(it.hasNext()){ 51 //通过key获取value 52 Integer key = it.next(); 53 String value = map.get(key); 54 System.out.println(key+"="+value); 55 } 56 57 58 System.out.println("-------------"); 59 for(Integer key:keys){ 60 System.out.println(key+"="+map.get(key)); 61 } 62 System.out.println("----------第二种方式---------------"); 63 //第二种方式 Set<Map.Entry<K,V>> entrySet() 将Map集合转换为set集合 64 //set集合元素类型是:Map.Entry 65 Set<Entry<Integer, String>> set = map.entrySet(); 66 //遍历set集合,取出每个Node 67 //迭代器 68 Iterator<Entry<Integer, String>> it2 = set.iterator(); 69 while (it2.hasNext()){ 70 Entry<Integer, String> node = it2.next(); 71 72 Integer key = node.getKey(); 73 String value = node.getValue(); 74 System.out.println(key+"="+value); 75 } 76 System.out.println("----------foreach---------"); 77 //foreach 78 for(Map.Entry<Integer, String> node:set){ 79 System.out.println(node.getKey()+"="+node.getValue()); 80 } 81 82 } 83 84 }
3、了解哈希表数据结构。
4、存放在HashMap集合key部分和HashSet集合中的元素需要同时重写hashCode和equals。
不重写添加不了相同的元素
1 package javase.map; 2 3 public class Student { 4 private String name; 5 6 public String getName() { 7 return name; 8 } 9 10 public void setName(String name) { 11 this.name = name; 12 } 13 14 public Student(String name) { 15 super(); 16 this.name = name; 17 } 18 19 public Student() { 20 super(); 21 22 } 23 24 @Override 25 public int hashCode() { 26 final int prime = 31; 27 int result = 1; 28 result = prime * result + ((name == null) ? 0 : name.hashCode()); 29 return result; 30 } 31 32 @Override 33 public boolean equals(Object obj) { 34 if (this == obj) 35 return true; 36 if (obj == null) 37 return false; 38 if (getClass() != obj.getClass()) 39 return false; 40 Student other = (Student) obj; 41 if (name == null) { 42 if (other.name != null) 43 return false; 44 } else if (!name.equals(other.name)) 45 return false; 46 return true; 47 } 48 49 50 }
main方法:
1 package javase.map; 2 3 import java.util.HashSet; 4 import java.util.Set; 5 6 /** 7 * hashMap集合 8 * @author ASUS 9 *1.HashMap集合底层是哈希表/散列表的数据结构 10 *2.哈希表是一个怎样的数据结构 11 *3.源码 12 *4.最主要掌握 13 * map.put(k,v) 14 * v=map.get(k) 15 *5.HashMap集合的key部分特点: 16 * 无序,不可重复 17 * 无序:因为不一定挂到哪个链表上 18 * 不可重复:equals方法保证HashMap集合key不可重复 19 * 如果重复了,value会覆盖 20 * 21 * 放在HashMap集合key部分的元素其实就是放到HashSet集合中了 22 * 所以HashSet集合中的元素也需要同时重写hashCoed()+equals()方法 23 *6.哈希表HashMap集合使用不当时,不能发挥其性能 24 * 假设所有HAshMap()方法返回值固定为某个值,那么会导致底层哈希表变成一个纯单向列表, 25 * 我们称为:散列分布不均匀 26 * 假设所有HAshMap()方法返回值设置为不同的值,那么会导致底层哈希表变成一个一维数组, 27 *7.放在HashMap集合key部分的元素,以及放在HashSet集合的元素,都需要同时重写hashCode和equals方法 28 *8.HashMap集合的默认初始化容量是16,默认加载因子是0.75 29 * 底层容量达到75%进行扩容 30 * 重点:记住:MashMAp集合初始化容量必须是2的倍数,也是官方推荐,为了达到散列分布均匀 ,提高效率 31 * 32 * 33 *一个类equals方法重写,hashCode方法必须重写 34 * 35 * 36 * 37 */ 38 public class HashMapTest01 { 39 40 public static void main(String[] args) { 41 42 Student s1=new Student("zhang"); 43 Student s2=new Student("zhang"); 44 45 46 Set<Student> students=new HashSet<>(); 47 48 students.add(s1); 49 students.add(s2); 50 System.out.println(students.size()); 51 52 53 } 54 55 }
5、HashMap和Hashtable的区别。
HashMap：
初始化容量16，扩容2倍。
非线程安全
key和value可以为null。
Hashtable
初始化容量11，扩容2倍+1
线程安全
key和value都不能是null。
6、Properties类的常用两个方法。
setProperty
getProperty
1 package javase.map; 2 3 import java.util.Properties; 4 5 /** 6 * Properties 属性类 7 * @author ASUS 8 * 是一个Map集合,继承Hashtable,key和value都是String类型 9 */ 10 public class PropertiesTest01 { 11 12 public static void main(String[] args) { 13 Properties pro = new Properties(); 14 pro.setProperty("url", "jdbc:mysql://locathost:3306/bc"); 15 pro.setProperty("driver", "com.mysql.jdbc.Driver"); 16 pro.setProperty("username", "root"); 17 pro.setProperty("password", "123"); 18 19 String url = pro.getProperty("url"); 20 String driver = pro.getProperty("driver"); 21 String username = pro.getProperty("username"); 22 String password = pro.getProperty("password"); 23 24 System.out.println(url); 25 System.out.println(driver); 26 System.out.println(username); 27 System.out.println(password); 28 33 } 34 35 }
7、了解自平衡二叉树数据结构。
左小右大原则存储。
中序遍历方式。
8、TreeMap的key或者TreeSet集合中的元素要想排序，有两种实现方式：
第一种：实现java.lang.Comparable接口。
不实现报错:
1 package javase.map; 2 /** 3 * TreeSet集合 4 * 遍历后自动排序 5 */ 6 import java.util.TreeSet; 7 8 public class TreeSetTest02 { 9 public static void main(String[] args) { 10 Person1 p1=new Person1(32); 11 Person1 p2=new Person1(22); 12 Person1 p3=new Person1(34); 13 Person1 p4=new Person1(12); 14 15 TreeSet<Person1> person = new TreeSet<>(); 16 person.add(p1); 17 person.add(p2); 18 person.add(p3); 19 person.add(p4); 20 21 for(Person1 p:person){ 22 System.out.println(p); 23 } 24 } 25 } 26 class Person1 implements Comparable<Person1>{ 27 int age; 28 public Person1(int age){ 29 this.age=age; 30 } 31 @Override 32 public String toString() { 33 34 return "Person[age="+age+"]"; 35 } 36 //需要在这个方法中编写比较的逻辑,或者规则 37 @Override 38 public int compareTo(Person1 o) { 39 40 return o.age-this.age; 41 } 42 }
第二种：单独编写一个比较器Comparator接口。
1 package javase.map; 2 /** 3 * TreeSet集合 4 * 需求:按年龄进行进行降序排序,年龄相同,按姓名排序 5 */ 6 import java.util.TreeSet; 7 8 public class TreeSetTest03 { 9 public static void main(String[] args) { 10 vip v1=new vip(23, "李四"); 11 vip v2=new vip(22, "张三"); 12 vip v3=new vip(25, "王三"); 13 vip v4=new vip(22, "李三"); 14 15 TreeSet<vip> t = new TreeSet<>(); 16 t.add(v1); 17 t.add(v2); 18 t.add(v3); 19 t.add(v4); 20 21 for(vip v:t){ 22 System.out.println(v); 23 } 24 25 } 26 } 27 class vip implements Comparable<vip>{ 28 int age; 29 String name; 30 31 @Override 32 public String toString() { 33 34 return "vip{"+"age="+age+","+"name="+name+ 35 36 "}"; 37 } 38 39 40 public vip(int age, String name) { 41 super(); 42 this.age = age; 43 this.name = name; 44 45 46 } 47 //二叉树 遵循左小右大 48 //>0执行树右边 <0树左边 =0 value会覆盖 49 @Override 50 public int compareTo(vip a) { 51 if(this.age==a.age){ 52 return a.name.compareTo(this.name); 53 }else{ 54 return this.age-a.age; 55 } 56 57 } 58 }
1 package javase.map; 2 3 import java.util.Comparator; 4 import java.util.TreeSet; 5 6 /** 7 * TreeSet集合元素可排序的第二种方法:使用比较器的方法 8 * treeSet 和TreeMap集合key部分想做到排序的话有两种方法: 9 * 第一种:放在集合中的元素实现java.long.Commparable接口 10 * 第二种:在构造TreeSet或者TreeMap的时候给他传一个比较器对象 11 * Comparable和Comparator怎么选择: 12 * 规则不容易改变 Comparable 13 * 规则容易改变 Comparator 14 * @author ASUS 15 * 16 */ 17 public class TreeSetTest04 { 18 19 public static void main(String[] args) { 20 //TreeSet<wugui> wuguis = new TreeSet<>(new wuguiComparator()); 21 TreeSet<wugui> wuguis = new TreeSet<>(new Comparator<wugui>() { 22 23 @Override 24 public int compare(wugui o1, wugui o2) { 25 26 return o1.age-o2.age; 27 } 28 29 }); 30 31 32 wuguis.add(new wugui(4123)); 33 wuguis.add(new wugui(433)); 34 wuguis.add(new wugui(1243)); 35 36 for(wugui w : wuguis){ 37 System.out.println(w); 38 } 39 40 41 } 42 43 } 44 class wugui{ 45 int age; 46 47 public wugui(int age) { 48 super(); 49 this.age = age; 50 } 51 52 @Override 53 public String toString() { 54 55 return "wugui{"+"age="+age+'}'; 56 } 57 58 59 } 60 //单独编写比较器 61 // 62 //class wuguiComparator implements Comparator<wugui>{ 63 // 64 // @Override 65 // public int compare(wugui o1, wugui o2) { 66 // 67 // return o1.age-o2.age; 68 // } 69 // 70 //}
9、集合工具类Collections:
synchronizedList方法
sort方法（要求集合中元素实现Comparable接口。）
1 package javase.collection; 2 3 import java.util.ArrayList; 4 import java.util.Collections; 5 import java.util.HashSet; 6 import java.util.List; 7 import java.util.Set; 8 9 /* 10 * 集合工具类 11 * 12 * java.util.Collection 集合接口 13 * java.util.Collections 集合工具类 14 * 15 */ 16 public class CollectionsTest { 17 18 public static void main(String[] args) { 19 //ArrayList集合不是线程安全的 20 List<String> list=new ArrayList<>(); 21 //变成线程安全的 22 Collections.synchronizedList(list); 23 24 //排序 25 list.add("avju"); 26 list.add("abc"); 27 list.add("def"); 28 list.add("ghj"); 29 list.add("xyz"); 30 31 //sort 排序 32 Collections.sort(list); 33 for(String s:list){ 34 System.out.println(s); 35 } 36 List<wugui2> wuguis=new ArrayList<>(); 37 38 wuguis.add(new wugui2(123314)); 39 wuguis.add(new wugui2(23314)); 40 wuguis.add(new wugui2(3314)); 41 wuguis.add(new wugui2(43241)); 42 43 //对List集合元素排序,需要集合实现Comparable接口 44 Collections.sort(wuguis); 45 for(wugui2 wg:wuguis){ 46 System.out.println(wg); 47 } 48 System.out.println("------"); 49 50 //对set集合怎么排序 51 Set<String> set=new HashSet<>(); 52 set.add("abc"); 53 set.add("def"); 54 set.add("ghj"); 55 set.add("xyz"); 56 //将Set集合转换为List 57 List<String> list2=new ArrayList<String>(set); 58 Collections.sort(list2); 59 for(String sc:list2){ 60 System.out.println(sc); 61 } 62 63 64 65 } 66 67 } 68 class wugui2 implements Comparable<wugui2>{ 69 int age; 70 71 public wugui2(int age) { 72 super(); 73 this.age = age; 74 } 75 76 @Override 77 public String toString() { 78 79 return "乌龟{"+"age="+age+'}'; 80 } 81 82 83 @Override 84 public int compareTo(wugui2 o) { 85 86 return this.age-o.age; 87 } 88 89 }
