概述

集合本质上就是一个存储数据的容器，数组就是集合的一种数据类型。集合不能直接存储基本数据类型和Java对象，只能存储Java对象的内存地址(或者叫引用)，如下图所示：
集合类 - 图1
Java中不同的集合对应不同的数据结构。往不同的集合中存储元素就是往不同的数据结构中存储元素，这些数据结构包括数组、二叉树、链表、哈希表等。
集合是在java.util.*包下的，集合的整个继承体系是非常庞杂的。总的来说，根据集合体系的元素的存储方式(以单个方式存储元素、以键值对存储元素)的不同，将集合体系分成Collection集合和Map集合，分别在java.util.Collection包和java.util.Map包下。

Collection集合体系继承关系

Collection集合体系如下：
集合类 - 图2集合类 - 图3
注意，Collection是个接口，它继承了Iterator接口，用法如下：
Iterator it = “Collection对象”.iterator();
it是迭代器对象

Map集合体系的继承关系

Map集合体系的继承关系如下：
集合类 - 图4

  1. /**
  2.      * The bin count threshold for using a tree rather than list for a
  3.      * bin.  Bins are converted to trees when adding an element to a
  4.      * bin with at least this many nodes. The value must be greater
  5.      * than 2 and should be at least 8 to mesh with assumptions in
  6.      * tree removal about conversion back to plain bins upon
  7.      * shrinkage.
  8.      */
  9.     static final int TREEIFY_THRESHOLD = 8;
  11.     /**
  12.      * The bin count threshold for untreeifying a (split) bin during a
  13.      * resize operation. Should be less than TREEIFY_THRESHOLD, and at
  14.      * most 6 to mesh with shrinkage detection under removal.
  15.      */
  16.     static final int UNTREEIFY_THRESHOLD = 6;
  18.     /**
  19.      * The smallest table capacity for which bins may be treeified.
  20.      * (Otherwise the table is resized if too many nodes in a bin.)
  21.      * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
  22.      * between resizing and treeification thresholds.
  23.      */
  24.     static final int MIN_TREEIFY_CAPACITY = 64;

集合类 - 图5集合类 - 图6

Collection接口

普通常用方法

image.png

  1. package javase.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  6. /*
  7. 1、Collection中能存放什么元素？
  8.     未使用泛型之前，Collection可以存储Object类的所有子类型
  9.     使用泛型之后，Collection中只能存放某个具体的数据类型。
  10. 2、Collection的常用方法：add();clear();size();contain();remove();toCharArray();iterator();
  11.  */
  12. public class ClooectionTest01 {
  13.     public static void main(String[] args) {
  14.         Collection c = new ArrayList(); //多态
  15.         c.add("zs");
  16.         c.add(125); //就算是这里，其实集合存储的还是引用
  17.         c.add(new Student());
  18.         c.add(129);
  19.         System.out.println(c.size());   //3
  20.         System.out.println(c.contains("zs"));//true
  21.         System.out.println(c.remove(125));//true
  22.         Object[] objects = c.toArray();
  23.         for (int i = 0; i < objects.length; i++) {
  24.             //zs    javase.collection.Student@1b6d3586    129
  25.             System.out.print(objects[i]+"\t");
  26.         }
  28.     }
  29. }
  31. class Student{
  33. }

重点常用方法（亟待加强）

iterator方法（其一）

  1. package javase.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.HashSet;
  6. import java.util.Iterator;
  8. /**
  9.  * 迭代专题：Collection及其子实现能用，Map接口不行
  10.  */
  11. public class CollectionTest02 {
  12.     public static void main(String[] args) {
  13.         Collection c = new ArrayList();
  14.         c.add("zs");
  15.         c.add("ls");
  16.         c.add(123); //存进去是什么类型，取出来还是什么类型，只是输出时会转成字符串
  17.         c.add(123);
  18.         Iterator it = c.iterator();
  19.         while (it.hasNext()){
  20.             System.out.print(it.next()+"\t"); //zs    ls    123  123
  21.         }
  23.         Collection c2 = new HashSet();
  24.         c2.add(1);
  25.         c2.add(20);
  26.         c2.add(5);
  27.         c2.add(99);
  28.         c2.add(90);
  29.         c2.add(99);
  30.         Iterator it2 = c2.iterator();
  31.         while (it2.hasNext()){
  32.             //1    99    20    5    90,无序且不可重复
  33.             System.out.print(it2.next()+"\t");
  34.         }
  35.     }
  36. }

iterator方法（其二）

  1. package javase.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.Iterator;
  7. /*
  8. 关于集合元素的remove方法
  9.     重点：当集合的结构发生改变时，迭代器必须重新获取，如果还是用以前老的迭代器，
  10.         会出现并发修改异常java.util.ConcurrentModificationException。
  11.         在迭代集合元素的过程中，不能调用集合对象的remove方法删除元素。
  12.  */
  13. public class CollectionTest05 {
  14.     public static void main(String[] args) {
  15.         /*Collection c = new ArrayList();
  16.         *//**
  17.          * 注意：此时获取的迭代器，指向的是集合中没有元素状态下的迭代器
  18.          *      集合结构一旦发生改变，迭代器必须重新获取
  19.          *//*
  20.         Iterator it = c.iterator();
  21.         c.add(1);
  22.         c.add(2);
  23.         c.add(3);
  25.         while (it.hasNext()){
  26.             //Exception in thread "main" java.util.ConcurrentModificationException
  27.             Object obj = it.next();
  28.             System.out.print(obj+"  ");
  29.         }*/
  31.         Collection c2 = new ArrayList();
  32.         c2.add(999);
  33.         c2.add("zs");
  34.         c2.add(new Object());
  36.         Iterator it2 = c2.iterator();
  37.         while (it2.hasNext()){
  38.             //未做任何修改之前输出：
  39.             //999 zs java.lang.Object@1b6d3586
  40.             Object obj2 = it2.next();
  42.             //添加一行删除元素的代码后输出：
  43.             //999 Exception in thread "main" java.util.ConcurrentModificationException
  44. //          c2.remove(obj2);  //直接通过集合去删除元素，没有通知迭代器，
  45.             //导致快照和原集合状态不同，产生并发修改异常
  46.             System.out.print(obj2+" ");
  47.         }
  48.         //使用迭代器可以删除，删除的一定是迭代器指向的当前元素
  49.         it2.remove();
  50.         System.out.println(c2.size());  //2
  51.     }
  52. }

image.png
image.png

contains方法

  1. package javase.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  6. //总结，放在Collection集合的类型一定要重写equals方法
  7. public class CollectionTest03 {
  8.     public static void main(String[] args) {
  9.         Collection c = new ArrayList();
  10.         String s1 = new String("123");
  11.         String s2 = new String("234");
  12.         String s3 = new String("123");
  13.         c.add(s1);
  14.         c.add(s2);
  15.         //之所以输出为true，是因为存储元素时会比较内容，
  16.         // contains方法先调用indexof方法，然后indexof方法调用indexOfRange方法
  17.         // 最后indexOfRange调用equals方法
  18.         System.out.println(c.contains(s3)); //true
  21.         Collection c2 = new ArrayList();
  22.         User user1 = new User("zs");
  23.         User user2 = new User("zs");
  24.         c2.add(user1);
  25.         //输出结果为false，因为User类没有重写equals方法，比较的是地址
  26.         System.out.println(c2.contains(user2)); //false
  29.     }
  30. }
  32. class User{
  33.     private String name;
  35.     public User() {
  36.     }
  38.     public User(String name) {
  39.         this.name = name;
  40.     }
  41. }

image.png

remove方法

  1. package javase.collection;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  6. //测试remove()方法有没有重写equals方法
  7. public class CollectionTest04 {
  8.     public static void main(String[] args) {
  9.         Collection c = new ArrayList();
  10.         String s1 = new String("hello");
  11.         String s2 = new String("hello");
  12.         c.add(s1);
  13.         System.out.println(c.contains(s2));//true
  14.         System.out.println(c.remove(s2));//true
  15.         System.out.println(c.size());//0
  16.     }
  17. }

总结

加入Collection集合的对象需要重写equals方法，除非像String那种已经重写了equals()方法的就不必了，一般自定义的类都要重写。

List接口

自身特色方法

  1. package javase.list;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. /*
  8.     测试List接口的常用方法：
  9.     1、存储特点：有序可重复
  10.     2、自身特色方法：
  11.         ①void    add(int index, E element)
  12.           在列表的指定位置插入指定元素（可选操作）。
  13.         ②E    get(int index)
  14.           返回列表中指定位置的元素。
  15.         ③int    hashCode()
  16.           返回列表的哈希码值。
  17.         ④int    indexOf(Object o)
  18.           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
  19.         ⑤E    set(int index, E element)
  20.           用指定元素替换列表中指定位置的元素（可选操作）。
  21.  */
  22. public class ListTest01 {
  23.     public static void main(String[] args) {
  24.         List myList = new ArrayList();
  25.         myList.add("1");
  26.         myList.add(2);
  27.         myList.add("999");
  28.         //向指定位置添加元素，用得不多
  29.         myList.add(1,777);
  31.         Iterator mle = myList.iterator();
  32.         while (mle.hasNext()){
  33.             Object obj = mle.next();
  34.             //1  777  2  999
  35.             System.out.print(obj+"  ");
  36.         }
  38.         //获取下标元素
  39.         Object obj2 = myList.get(1);
  40.         System.out.println(obj2);   //777
  41.         //获取下标元素，改进
  42.         for (int i = 0; i < myList.size(); i++) {
  43.             //1  777  2  999
  44.             System.out.print(myList.get(i)+"  ");
  45.         }
  47.         //获取元素第一次、最后一次出现处的索引
  48.         System.out.println(myList.indexOf(777));  //1
  49.         System.out.println(myList.lastIndexOf(777)); //1
  51.         //根据下标删除元素
  52.         Object obj3 = myList.remove(1);
  53.         System.out.println(myList.size());  //3
  55.         //修改元素
  56.         myList.set(1,"这就是中国");
  57.         System.out.println(myList.get(1)); //这就是中国
  59.         //查看整体
  60.         for (int i = 0; i < myList.size(); i++) {
  61.             //1  这就是中国  999  
  62.             System.out.print(myList.get(i)+"  ");
  63.         }
  64.     }
  65. }

子实现之ArrayList

特点

  1. /**
  2.      * Default initial capacity.
  3.      */
  4.     //初始容量是10
  5.     //底层先创建一个长度为0的数组，当添加第一个元素的时候初始化容量为10
  6.     private static final int DEFAULT_CAPACITY = 10;
  8.     //底层是个Object类型的数组
  9.     transient Object[] elementData;
  11.     //扩容机制，是原来的1.5倍
  12. /**
  13.      * Increases the capacity to ensure that it can hold at least the
  14.      * number of elements specified by the minimum capacity argument.
  15.      *
  16.      * @param minCapacity the desired minimum capacity
  17.      */
  18.     private void grow(int minCapacity) {
  19.         // overflow-conscious code
  20.         int oldCapacity = elementData.length;
  21.         int newCapacity = oldCapacity + (oldCapacity >> 1);
  22.         if (newCapacity - minCapacity < 0)
  23.             newCapacity = minCapacity;
  24.         if (newCapacity - MAX_ARRAY_SIZE > 0)
  25.             newCapacity = hugeCapacity(minCapacity);
  26.         // minCapacity is usually close to size, so this is a win:
  27.         elementData = Arrays.copyOf(elementData, newCapacity);
  28.     }
  30.     //带一个整型参数的构造器：可以自定义初始容量
  31.     public ArrayList(int initialCapacity) {
  32.             if (initialCapacity > 0) {
  33.                 this.elementData = new Object[initialCapacity];
  34.             } else if (initialCapacity == 0) {
  35.                 this.elementData = EMPTY_ELEMENTDATA;
  36.             } else {
  37.                 throw new IllegalArgumentException("Illegal Capacity: "+
  38.                                                    initialCapacity);
  39.             }
  40.    }
  41.     //带一个集合类型参数的构造器
  42. /**
  43.      * Constructs a list containing the elements of the specified
  44.      * collection, in the order they are returned by the collection's
  45.      * iterator.
  46.      *
  47.      * @param c the collection whose elements are to be placed into this list
  48.      * @throws NullPointerException if the specified collection is null
  49.      */
  50.     public ArrayList(Collection<? extends E> c) {
  51.         elementData = c.toArray();
  52.         if ((size = elementData.length) != 0) {
  53.             // c.toArray might (incorrectly) not return Object[] (see 6260652)
  54.             if (elementData.getClass() != Object[].class)
  55.                 elementData = Arrays.copyOf(elementData, size, Object[].class);
  56.         } else {
  57.             // replace with empty array.
  58.             this.elementData = EMPTY_ELEMENTDATA;
  59.         }
  60.     }
  63.     //无参构造器
  64.     /**
  65.          * Constructs an empty list with an initial capacity of ten.
  66.          */
  67.         public ArrayList() {
  68.             this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  69.         }

ArrayList集合类3个构造方法

  1. package javase.list.arraylist;
  3. import java.util.ArrayList;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Set;
  8. public class ArrayListTest01 {
  9.     public static void main(String[] args) {
  10.         //默认数组初始容量为10
  11.         List c1 = new ArrayList();
  12.         //指定数组初始容量为100
  13.         List c2 = new ArrayList(100);
  15.         //将一个集合作为参数传到ArrayList集合类中
  16.         Set  set = new HashSet();
  17.         set.add(11);
  18.         set.add(22);
  19.         set.add(33);
  20.         set.add(44);
  21.         List c3 = new ArrayList(set);
  23.         for (int i = 0; i < set.size(); i++) {
  24.             System.out.print(c3.get(i)+" ");  //33 22 11 44 
  25.         }
  26.     }
  27. }

子实现之LinkedList

  1. package javase.list;
  3. import java.util.LinkedList;
  4. import java.util.List;
  6. /**
  7.  * 链表的优点：
  8.  *    由于链表上的元素在空间存储上内存地址不连续
  9.  *    所以随机增删的时候不会有大量元素位移，因此随机增删效率较高
  10.  * 链表的缺点：
  11.  *    不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头开始遍历，
  12.  *    直到找到为止，所以LinkedList集合检索效率较低
  13.  *
  14.  * ArrayList：把检索发挥到极致
  15.  * LinkedList：本质上是双向链表，把随机增删发挥到极致
  16.  * 由于添加元素都是往末尾添加的，而ArrayList末尾添加元素效率还是很高的，
  17.  *      所以ArrayList用得比LinkedList多
  18.  */
  19. public class LinkedListTest01 {
  20.     public static void main(String[] args) {
  21.         List c = new LinkedList();
  22.         c.add(100);
  23.         c.add(200);
  24.         c.add(300);
  25.         c.add(400);
  27.         for (int i = 0; i < c.size(); i++) {
  28.             //100 200 300 400
  29.             System.out.print(c.get(i)+" ");
  30.             /*
  31.             同ArrayList一样，LinkedList也是有下标的
  32.             注意：ArrayList之所以检索效率比较高，不是单纯因为下标的原因，而是因为底层数组发挥了作用
  33.             LinkedList集合照样有下标，只是检索某个元素的时候效率比较低，因为只能从头结点开始一个一个遍历
  34.              */
  35.         }
  36.     }
  37. }

子实现之Vector

  1.     //初始容量是10
  2. /**
  3.      * Constructs an empty vector so that its internal data array
  4.      * has size {@code 10} and its standard capacity increment is
  5.      * zero.
  6.      */
  7.     public Vector() {
  8.         this(10);
  9.     }
  11.     //扩容机制是原来的2倍
  12. /**
  13.      * The amount by which the capacity of the vector is automatically
  14.      * incremented when its size becomes greater than its capacity.  If
  15.      * the capacity increment is less than or equal to zero, the capacity
  16.      * of the vector is doubled each time it needs to grow.
  17.      *
  18.      * @serial
  19.      */
  20.     protected int capacityIncrement;
  22.     //随便列举一个方法，证明Vector是线程安全的
  23.     /**
  24.      * Returns the number of components in this vector.
  25.      *
  26.      * @return  the number of components in this vector
  27.      */
  28.     public synchronized int size() {
  29.         return elementCount;
  30.     }

如何将ArrayList类转成线程安全的？

  1. package javase.list;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  5. import java.util.List;
  7. public class ListTest02 {
  8.     public static void main(String[] args) {
  9.         //非线程安全的
  10.         List myList = new ArrayList();
  12.         //如何将其变成线程安全的？这行的代码
  13.         Collections.synchronizedList(myList);
  15.         myList.add(10);
  16.         myList.add(20);
  17.         myList.add(30);
  18.     }
  19. }

泛型

普通泛型

  1. package javase.generic;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. /*jdk5.0推出的泛型机制
  8. 1、泛型这种语法机制，只在程序编译阶段起作用，只是给编译器参考的，运行阶段泛型没用
  9. 2、优点：
  10.     ①集合存储的元素统一了
  11.     ②从集合中取出的元素类型是泛型指定的类型，不需要进行大量的向下转型
  12. 3、缺点：
  13.     ①导致集合中存储的元素缺乏多样性
  14.     ②大多数业务中，集合中的元素还是统一的，所以泛型的这种特性还是被大家认可的
  15.  */
  17. public class GenericTest01 {
  18.     public static void main(String[] args) {
  19.         /*List myList = new ArrayList();
  21.         Cat c = new Cat();
  22.         Bird b = new Bird();
  24.         myList.add(c);
  25.         myList.add(b);
  27.         Iterator it = myList.iterator();
  28.         //遍历集合，取出每个Animal，让它move
  29.         while (it.hasNext()){
  30.             Object obj = it.next();
  31.             if (obj instanceof Animal){
  32.                 Animal a = (Animal) obj;
  33.                 a.move();
  34.             }
  35.         }
  36.     }*/
  37.         //使用泛型List<Animal>之后，表示List集合中只允许存储Animal类型的数据
  38.         //用泛型来指定集合中存储的数据元素
  39.         List<Animal> myList2 = new ArrayList<>();
  41.         //指定List集合中只能存储Animal，那么，存储String就编译报错了
  42.         //这样使用泛型之后，集合中元素的数据类型就更加统一了
  43.         Cat c = new Cat();
  44.         Bird b = new Bird();
  46.         myList2.add(c);
  47.         myList2.add(b);
  49.         //获取迭代器，这个表示迭代器迭代的是Animal类型
  50.         Iterator<Animal> it2 = myList2.iterator();
  51.         while (it2.hasNext()){
  52.             //使用泛型之后，每一次迭代返回的都是Animal类型
  53.             Animal a2 = it2.next();
  54.             //这里不需要进行强制类型转换了，直接调用
  55.             //但是调用子类特有的方法还是需要向下转型的
  56.             a2.move();
  57.         }
  58.     }
  60. }
  62. class Animal{
  63.     public void move(){
  64.         System.out.println("动物在移动");
  65.     }
  66. }
  68. class Cat extends Animal{
  69.     public void catchMouse(){
  70.         System.out.println("猫抓老鼠");
  71.     }
  72. }
  74. class Bird extends Animal{
  75.     public void fly(){
  76.         System.out.println("鸟儿在飞翔");
  77.     }
  78. }
  80. //2种方式都输出：
  81. // 动物在移动
  82. //动物在移动

自定义泛型

  1. package javase.generic;
  3. //自定义泛型
  4. //定义时先是以某种格式，而后使用时是指定类型格式
  5. public class GenericTest03<MyType> {
  6.     public void doSome(MyType mt){
  7.         System.out.println(mt);
  8.     }
  10.     public static void main(String[] args) {
  11.         GenericTest03<String> gt = new GenericTest03<>();
  13.         //类型不匹配
  14. //        gt.doSome(100);
  16.         //类型匹配
  17.         gt.doSome("abc");    //abc
  18.     }
  19. }

增强for循环

定义

  1. package javase.forcycle;
  3. public class StrongerForCycleTest01 {
  4.     public static void main(String[] args) {
  5.         int arr[] = {1,2,3,4,5,232,43,434,2135,65};
  6.         //普通for循环
  7.         for (int i = 0; i < arr.length; i++) {
  8.             System.out.print(arr[i]+" ");
  9.         }
  10.         //增强for循环（语法格式如下：）
  11.         /*
  12.         for(元素类型 变量名：数组或集合){
  13.             变量名.sout;
  14.         }
  15.          */
  16.         System.out.println("\n"+"===================================");
  17.         //i就是数组中的每一个元素，foreach缺点是没有下标，
  18.         //这里建议没有下标时采用增强for循环
  19.         //同时建议采用：arr.iter格式快速生成增强for循环语法格式
  20.         for (int i : arr) {
  21.             System.out.print(i+"  ");
  22.         }
  24.     }
  25. }
  26. /*
  27. 输出如下：
  28. 1 2 3 4 5 232 43 434 2135 65
  29. ===================================
  30. 1  2  3  4  5  232  43  434  2135  65
  31.  */

集合三类循环的比较

  1. package javase.forcycle;
  3. import java.util.ArrayList;
  4. import java.util.Iterator;
  5. import java.util.List;
  7. //三种方式遍历集合
  8. public class StrongerForCycleTest02 {
  9.     public static void main(String[] args) {
  10.         List<String> mylist = new ArrayList<>();
  11.         mylist.add("my test01");
  12.         mylist.add("my test02");
  13.         mylist.add("my test03");
  15.         //方式一：迭代器遍历
  16.         Iterator<String> it1 = mylist.iterator();
  17.         while (it1.hasNext()){
  18.             String s1 = it1.next();
  19.             System.out.print(s1+"  ");
  20.         }
  21.         System.out.println();
  23.         //方式二：普通for循环
  24.         for (int i = 0; i < mylist.size(); i++) {
  25.             System.out.print(mylist.get(i)+"  ");
  26.         }
  27.         System.out.println();
  29.         //方式三：增强for循环
  30.         for (String s : mylist) {
  31.             System.out.print(s+"  ");
  32.         }
  33.     }
  34. }
  35. /*
  36. 结果输出：
  37.     my test01  my test02  my test03  
  38.     my test01  my test02  my test03  
  39.     my test01  my test02  my test03  
  40.  */

Set接口

HashSet集合类

HashSet类效果演示

  1. package javase.hashset;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. public class HashSetTest01 {
  7.     public static void main(String[] args) {
  8.         Set<String> strs = new HashSet<>();
  9.         strs.add("hello1");
  10.         strs.add("hello2");
  11.         strs.add("hello3");
  12.         strs.add("hello4");
  13.         strs.add("hello5");
  14.         strs.add("hello1");
  15.         strs.add("hello1");
  17.         for (String str : strs) {
  18.             //hello1  hello4  hello5  hello2  hello3  
  19.             System.out.print(str+"  ");
  20.             //存储时顺序和取出的顺序不同，不可重复，
  21.             // 且放到HashSet集合中的元素实际上是放到HashMap集合的key部分了
  22.         }
  23.     }
  24. }

TreeSet集合类

TreeSet类效果演示

  1. package javase.set.treeset;
  3. import java.util.Set;
  4. import java.util.TreeSet;
  6. //验证TreeSet的特性：①无序  ②不可重复
  7. //但存储的元素可以自动按照大小排序，称为可排序集合
  8. //这里的无序是指存入和取出的顺序不一样，没有下标
  9. public class TreeSetTest01 {
  10.     public static void main(String[] args) {
  11.         Set<String> strs = new TreeSet<>();
  12.         strs.add("A");
  13.         strs.add("B");
  14.         strs.add("Z");
  15.         strs.add("X");
  16.         strs.add("Y");
  17.         strs.add("Z");
  19.         for (String str : strs) {
  20.             //从小到大自动排序
  21.             System.out.print(str+" ");//A B X Y Z
  22.         }
  23.     }
  24. }

TreeSet无法对自定义类型进行排序★★

  1. package javase.set.treeset;
  3. import java.util.TreeSet;
  5. /*
  6. 1、TreeSet集合底层实际上是一个TreeMap
  7. 2、TreeMap集合底层是一个二叉树
  8. 3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分
  9. 4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序，被称为：可排序集合
  10.  */
  11. public class TreeSetTest02 {
  12.     //对于自定义的类型来说，TreeSet不可以排序
  13.     public static void main(String[] args) {
  14.         Person p1 = new Person(20);
  15.         Person p2 = new Person(30);
  16.         Person p3 = new Person(25);
  17.         Person p4 = new Person(35);
  19.         TreeSet<Person> persons = new TreeSet<>();
  20.         persons.add(p1);
  21.         persons.add(p2);
  22.         persons.add(p3);
  23.         persons.add(p4);
  25.         for (Person person : persons) {
  26.             System.out.println(person.toString());
  27.         }
  28.     }
  29. }
  31. class Person{
  32.     int age;
  34.     @Override
  35.     public String toString() {
  36.         return "Person{" +
  37.                 "age=" + age +
  38.                 '}';
  39.     }
  41.     public Person(int age) {
  42.         this.age = age;
  43.     }
  44. }

运行结果如下图：
image.png

探究原因

要在TreeMap的put方法中去找：

  1.     /**
  2.      * Constructs a new, empty tree set, sorted according to the
  3.      * natural ordering of its elements.  All elements inserted into
  4.      * the set must implement the {@link Comparable} interface.
  5.      * Furthermore, all such elements must be <i>mutually
  6.      * comparable</i>: {@code e1.compareTo(e2)} must not throw a
  7.      * {@code ClassCastException} for any elements {@code e1} and
  8.      * {@code e2} in the set.  If the user attempts to add an element
  9.      * to the set that violates this constraint (for example, the user
  10.      * attempts to add a string element to a set whose elements are
  11.      * integers), the {@code add} call will throw a
  12.      * {@code ClassCastException}.
  13.      */
  14.     public TreeSet() {
  15.         this(new TreeMap<E,Object>());
  16.     }
  18.     /**
  19.      * Constructs a new, empty tree map, using the natural ordering of its
  20.      * keys.  All keys inserted into the map must implement the {@link
  21.      * Comparable} interface.  Furthermore, all such keys must be
  22.      * <em>mutually comparable</em>: {@code k1.compareTo(k2)} must not throw
  23.      * a {@code ClassCastException} for any keys {@code k1} and
  24.      * {@code k2} in the map.  If the user attempts to put a key into the
  25.      * map that violates this constraint (for example, the user attempts to
  26.      * put a string key into a map whose keys are integers), the
  27.      * {@code put(Object key, Object value)} call will throw a
  28.      * {@code ClassCastException}.
  29.      */
  30.     public TreeMap() {
  31.         comparator = null;
  32.     }
  34.     /**
  35.      * Adds the specified element to this set if it is not already present.
  36.      * More formally, adds the specified element {@code e} to this set if
  37.      * the set contains no element {@code e2} such that
  38.      * <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
  39.      * If this set already contains the element, the call leaves the set
  40.      * unchanged and returns {@code false}.
  41.      *
  42.      * @param e element to be added to this set
  43.      * @return {@code true} if this set did not already contain the specified
  44.      *         element
  45.      * @throws ClassCastException if the specified object cannot be compared
  46.      *         with the elements currently in this set
  47.      * @throws NullPointerException if the specified element is null
  48.      *         and this set uses natural ordering, or its comparator
  49.      *         does not permit null elements
  50.      */
  51.     public boolean add(E e) {
  52.         return m.put(e, PRESENT)==null;
  53.     }
  56.     /**
  57.      * Associates the specified value with the specified key in this map.
  58.      * If the map previously contained a mapping for the key, the old
  59.      * value is replaced.
  60.      *
  61.      * @param key key with which the specified value is to be associated
  62.      * @param value value to be associated with the specified key
  63.      *
  64.      * @return the previous value associated with {@code key}, or
  65.      *         {@code null} if there was no mapping for {@code key}.
  66.      *         (A {@code null} return can also indicate that the map
  67.      *         previously associated {@code null} with {@code key}.)
  68.      * @throws ClassCastException if the specified key cannot be compared
  69.      *         with the keys currently in the map
  70.      * @throws NullPointerException if the specified key is null
  71.      *         and this map uses natural ordering, or its comparator
  72.      *         does not permit null keys
  73.      */
  74.     public V put(K key, V value) {
  75.         Entry<K,V> t = root;
  76.         if (t == null) {
  77.             compare(key, key); // type (and possibly null) check
  79.             root = new Entry<>(key, value, null);
  80.             size = 1;
  81.             modCount++;
  82.             return null;
  83.         }
  84.         int cmp;
  85.         Entry<K,V> parent;
  86.         // split comparator and comparable paths
  87.         Comparator<? super K> cpr = comparator;
  88.         if (cpr != null) {
  89.             do {
  90.                 parent = t;
  91.                 cmp = cpr.compare(key, t.key);
  92.                 if (cmp < 0)
  93.                     t = t.left;
  94.                 else if (cmp > 0)
  95.                     t = t.right;
  96.                 else
  97.                     return t.setValue(value);
  98.             } while (t != null);
  99.         }
  100.         else {
  101.             if (key == null)
  102.                 throw new NullPointerException();
  103.             @SuppressWarnings("unchecked")
  104.          //这行就极有可能出现问题
  105.           //给人的启示就是，要实现Comparable接口，才能比较大小，才好转型，不会出现类型转换异常
  106.         //怎么做？实现Comparable接口，重写compareTo()方法，自定义规则
  107.                 Comparable<? super K> k = (Comparable<? super K>) key;
  108.             do {
  109.                 parent = t;
  110.                 cmp = k.compareTo(t.key);
  111.                 if (cmp < 0)
  112.                     t = t.left;
  113.                 else if (cmp > 0)
  114.                     t = t.right;
  115.                 else
  116.                     return t.setValue(value);
  117.             } while (t != null);
  118.         }
  119.         Entry<K,V> e = new Entry<>(key, value, parent);
  120.         if (cmp < 0)
  121.             parent.left = e;
  122.         else
  123.             parent.right = e;
  124.         fixAfterInsertion(e);
  125.         size++;
  126.         modCount++;
  127.         return null;
  128.     }

解决措施

1.bean类实现Comparable接口，重写compareTo()方法

  1. package javase.set.treeset;
  3. import java.util.TreeSet;
  5. //先按照年龄升序，如果年龄一样再按照姓名升序
  6. public class TreeSetTest05 {
  7.     public static void main(String[] args) {
  8.         TreeSet<Vip> vips = new TreeSet<>();
  9.         vips.add(new Vip("zs",20));
  10.         vips.add(new Vip("ls",30));
  11.         vips.add(new Vip("ww",60));
  12.         vips.add(new Vip("zl",27));
  14.         for (Vip vip : vips) {
  15.    //Vip{name='zs', age=20} Vip{name='zl', age=27} Vip{name='ls', age=30} Vip{name='ww', age=60}          
  16.             System.out.print(vip+" ");
  17.         }
  18.     }
  19. }
  21. class Vip implements Comparable<Vip>{
  22.     String name;
  23.     int age;
  25.     public Vip(String name, int age) {
  26.         this.name = name;
  27.         this.age = age;
  28.     }
  30.     @Override
  31.     public String toString() {
  32.         return "Vip{" +
  33.                 "name='" + name + '\'' +
  34.                 ", age=" + age +
  35.                 '}';
  36.     }
  38.     @Override
  39.     public int compareTo(Vip v) {
  40.         if (this.age == v.age){
  41.             //姓名是String类型，可以直接比，调用compareTo()来完成
  42.             return this.name.compareTo(v.name);
  43.         }else {
  44.             return this.age - v.age;
  45.         }
  46.     }
  48. }

2.使用比较器的方式

  1. package javase.set.treeset;
  4. import java.util.Comparator;
  5. import java.util.TreeSet;
  7. /**
  8.  * 放到TreeSet或者TreeMap集合key部分的元素想要做到排序，包括以下2种方式：
  9.  *    第一种：放在集合中的元素实现java.lang.Comparable接口
  10.  *    第二种：在构造TreeSet或者TreeMap集合的时候给它传一个比较器对象
  11.  * Comparable和Comparator怎么选择呢？
  12.  *    当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口
  13.  *    当比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口
  14.  *      Comparator接口的设计符合OCP原则
  15.  */
  16. public class TreeSetTest06 {
  17.     public static void main(String[] args) {
  18.         //创建TreeSet集合的时候，需要使用这个比较器
  19.         //注意：这样是不行的，没有通过构造器传递一个比较器进去
  20. //        TreeSet<Wugui> wuguis = new TreeSet<>();
  21.         TreeSet<Wugui> wuguis = new TreeSet<>(new WuguiComparator());
  22.         wuguis.add(new Wugui(1000));
  23.         wuguis.add(new Wugui(800));
  24.         wuguis.add(new Wugui(789));
  25.         wuguis.add(new Wugui(606));
  27.         for (Wugui wugui : wuguis) {
  28.         //小乌龟【age=606】 小乌龟【age=789】 小乌龟【age=800】 小乌龟【age=1000】
  29.             System.out.print(wugui+" ");
  30.         }
  31.     }
  32. }
  34. class Wugui{
  35.     int age;
  37.     public Wugui(int age) {
  38.         this.age = age;
  39.     }
  41.     @Override
  42.     public String toString() {
  43.         return "小乌龟【" +
  44.                 "age=" + age +
  45.                 '】';
  46.     }
  47. }
  49. //单独在这里编写一个比较器
  50. //比较器实现java.util.Comparator接口(Comparable是java.lang包下的，Comparator是java.util包下的)
  51. class WuguiComparator implements Comparator<Wugui>{
  53.     @Override
  54.     public int compare(Wugui o1, Wugui o2) {
  55.         //指定比较规则：按年龄排序
  56.         return o1.age - o2.age;
  57.     }
  58. }

Map接口

Map接口的普通常用方法

  1. package javase.map;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. /*
  8. java.util.Map接口中常用的方法：
  9.     1、Map集合以key和value的方式存储数据：键值对
  10.         key和value是引用数据类型；
  11.         key和value都是存储对象的内存地址
  12.         key起到主导的地位，value是key的一个附属品
  13.     2、Map接口常用方法：
  14.         void    clear() 清空Map集合
  15.         boolean    containsKey(Object key) 判断集合是否包含某个key
  16.         boolean    containsValue(Object value) 判断集合是否包含某个value
  17.         V    get(Object key) 通过key获取对应的value值
  18.         boolean    isEmpty()   判断集合是否为空
  19.         Set<K>    keySet()    获取所有的key（所有的key组成自己的set集合）
  20.         V    put(K key, V value) 添加一组键值对
  21.         V    remove(Object key)  根据key删除所在的键值对
  22.         int    size()  获取Map集合中元素的个数
  23.         Collection<V>    values() 获取所有的value，返回一个Collection
  24.         Set<Map.Entry<K,V>>    entrySet()  将Map集合转成Set集合
  25.             假设现在有一个Map集合，如下所示：
  26.                 map1集合对象：
  27.                 key             value
  28.                 -----------------------
  29.                 1               zhangsan
  30.                 2               lisi
  31.                 3               wangwu
  32.                 4               zhaoliu
  34.                 Set set = map1.entrySet();
  35.                 set集合对象：
  36.                 1=zhangsan【注意：Map集合通过entrySet()方法转换成的这个Set集合，Set集合中元素的类型是Map.EntrySet】
  37.                 2=lisi  【Map.Entry和String一样，都是一种类型的名字，只不过Map.Entry是静态内部类，是Map中的】
  38.                 3=wangwu
  39.                 4=zhaoliu
  40.  */
  41. public class MapTest01 {
  42.     public static void main(String[] args) {
  43.         Map<Integer,String> map = new HashMap<>();
  44.         map.put(1,"zs");
  45.         map.put(2,"ls");
  46.         map.put(3,"ww");
  47.         map.put(4,"zl");
  49.         //V    get(Object key) 通过key获取对应的value值
  50.         String val = map.get(2);
  51.         System.out.println(val); //ls
  53.         //int    size()  获取Map集合中元素的个数
  54.         System.out.println("键值对的数量" + map.size());//键值对的数量4
  56.         //V    remove(Object key)  根据key删除所在的键值对
  57.         map.remove(1);
  58.         System.out.println("键值对的数量" + map.size());//键值对的数量3
  60.         //boolean    containsKey(Object key) 判断集合是否包含某个key
  61.         //contains方法底层调用的都是equals进行比对的，所以自定义的类型需要重写equals方法
  62.         System.out.println(map.containsKey(new Integer(2)));//true
  63.         //boolean    containsValue(Object value) 判断集合是否包含某个value
  64.         System.out.println(map.containsValue("zs"));//false
  66.         //Collection<V>    values() 获取所有的value，返回一个Collection
  67.         Collection<String> values = map.values();
  68.         for (String value : values) {
  69.             System.out.print(" "+value);//ls ww zl
  70.         }
  72.         //void    clear() 清空Map集合
  73.         map.clear();
  74.         System.out.println("键值对的数量" + map.size());//键值对的数量0
  76.         //boolean    isEmpty()   判断集合是否为空
  77.         System.out.println(map.isEmpty());//true
  78.     }
  79. }

Map接口的遍历三种方式

  1. package javase.map;
  3. import java.util.HashMap;
  4. import java.util.Iterator;
  5. import java.util.Map;
  6. import java.util.Set;
  8. //Map集合的遍历
  9. public class MapTest02 {
  10.     public static void main(String[] args) {
  11.         Map<Integer,String> map = new HashMap<>();
  12.         map.put(1,"zs");
  13.         map.put(2,"ls");
  14.         map.put(3,"ww");
  15.         map.put(4,"zl");
  17.         Set<Integer> keys = map.keySet();
  19.         //前2种方式遍历：迭代器和foreach
  20.         Iterator<Integer> it = keys.iterator();
  21.         while (it.hasNext()){
  22.             //1:zs 2:ls 3:ww 4:zl
  23.             Integer key = it.next();
  24.             String value = map.get(key);
  25.             System.out.print(key+":"+value+" ");
  26.         }
  27.         System.out.println();
  28.         for (Integer key : keys) {
  29.             //1:zs 2:ls 3:ww 4:zl
  30.             System.out.print(key+":"+map.get(key)+" ");
  31.         }
  33.         System.out.println();
  35.         //第三种方式遍历：Set集合中元素的类型是：Map.Entry
  36.         // Set<Map.Entry<K,V>>    entrySet()  将Map集合转成Set集合
  37.         Set<Map.Entry<Integer, String>> set = map.entrySet();
  38.         //遍历Set集合，每次取出一个Node
  39.         //这种效率其实更高，因为key和value都是直接从node对象获取的
  40.         Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
  41.         while (it2.hasNext()){
  42.             Map.Entry<Integer, String> node = it2.next();
  43.             Integer key = node.getKey();
  44.             String value = node.getValue();
  45.             //1:zs    2:ls    3:ww    4:zl
  46.             System.out.print(key + ":" + value+"\t");
  47.         }
  48.         System.out.println();
  49.         for (Map.Entry<Integer, String> node : set) {
  50.             //1-->zs    2-->ls    3-->ww    4-->zl    
  51.             System.out.print(node.getKey() + "-->" + node.getValue()+"\t");
  52.         }
  53.     }
  54. }

image.png

HashMap集合类★★

重点方法：put和get

image.png

hashCode()方法和equals()方法重写的问题

  1. package javase.hashmap.bean;
  3. public class Student {
  4.     private String name;
  6.     public String getName() {
  7.         return name;
  8.     }
  10.     public void setName(String name) {
  11.         this.name = name;
  12.     }
  14.     public Student(String name) {
  15.         this.name = name;
  16.     }
  18.     public Student() {
  19.     }
  21.     //重写equals
  22.     public boolean equals(Object obj){
  23.         if (obj == null||!(obj instanceof Student))  return false;
  24.         if (obj == this)    return true;
  25.         Student s = (Student) obj;
  26.         if (this.name.equals(s.name))   return true;
  27.         return false;
  28.     }
  29. }
  1. package javase.hashmap;
  3. import javase.hashmap.bean.Student;
  5. import java.util.HashSet;
  7. /*
  8. 1、向Map集合中存，以及从Map集合中取，都是先调用key的hashCode方法，然后再调用equals方法。
  9.     equals方法有可能调，也可能不调。
  10. 2、拿put(k，v)和get(k)举例，什么时候不会调用?
  11.     k.hashCode()方法返回哈希值，哈希值经过哈希算法转换成数组下标；如果数组下标为null，
  12.     equals不需要执行。
  13. 3、hashCode方法和equals方法不用研究了，直接用IDEA工具生成，但这两个方法需要同时生成
  14. 4、终极结论：放在HashMap集合key部分的，以及放在HashSet集合中的元素，
  15.     需要同时重写hashCode方法和equals方法
  16.  */
  17. public class HashMapTest02 {
  18.     public static void main(String[] args) {
  19.         Student s1 = new Student("zs");
  20.         Student s2 = new Student("zs");
  22.         //重写equals方法之前是false,重写之后是true
  23.         System.out.println(s1.equals(s2));
  25.         System.out.println(s1.hashCode());
  26.         System.out.println(s2.hashCode());
  28.         //s1.equals(s2)结果已经是true了，表示s1和s2是一样的，同样地，那么往HashSet集合的话，
  29.         //按说只能放进去一个
  30.         HashSet<Student> students = new HashSet<>();
  31.         students.add(s1);
  32.         students.add(s2);
  33.         //按理说是1，实际上是2。所以一个类的equals方法重写了，那么hashCode()方法也必须重写
  34.         //并且equals方法返回如果是true，hashCode()方法返回的值必须一样
  35.         System.out.println(students.size());
  36.     }
  37. }

JDK8中HashMap新特性

  1. HashMap集合底层是哈希表，这种数据结构是非线程安全的。JDK8以后，如果哈希表单向链表中元素超过8个，单向链表这种数据结构会变成红黑树。当红黑树的节点数量小于6时，会重新把红黑树变成单向链表数据结构。这种方式也是为了提高检索效率，二叉树的检索会再次缩小扫描范围，提高效率。源码如下：
  1. /**
  2.      * The bin count threshold for using a tree rather than list for a
  3.      * bin.  Bins are converted to trees when adding an element to a
  4.      * bin with at least this many nodes. The value must be greater
  5.      * than 2 and should be at least 8 to mesh with assumptions in
  6.      * tree removal about conversion back to plain bins upon
  7.      * shrinkage.
  8.      */
  9.     static final int TREEIFY_THRESHOLD = 8;
  11.     /**
  12.      * The bin count threshold for untreeifying a (split) bin during a
  13.      * resize operation. Should be less than TREEIFY_THRESHOLD, and at
  14.      * most 6 to mesh with shrinkage detection under removal.
  15.      */
  16.     static final int UNTREEIFY_THRESHOLD = 6;
  18.     /**
  19.      * The smallest table capacity for which bins may be treeified.
  20.      * (Otherwise the table is resized if too many nodes in a bin.)
  21.      * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
  22.      * between resizing and treeification thresholds.
  23.      */
  24.     static final int MIN_TREEIFY_CAPACITY = 64;

HashMap集合类存放空值元素的问题

  1. package javase.hashmap;
  3. import java.util.HashMap;
  5. //HashMap集合key部分允许为null吗？允许,但只能有1个
  6. public class HashMapTest03 {
  7.     public static void main(String[] args) {
  8.         HashMap map = new HashMap();
  9.         map.put(null,null);
  10.         System.out.println(map.size()); //1
  11.         System.out.println(map.get(null));//null
  12.     }
  13. }

HashTable集合类

HashTable类的基本信息

初始容量、负载因子、扩容机制

  1.     /**
  2.      * Constructs a new, empty hashtable with a default initial capacity (11)
  3.      * and load factor (0.75).
  4.      */
  5.     //初始容量为11，负载因子为0.75
  6.     public Hashtable() {
  7.         this(11, 0.75f);
  8.     }
  11.     /**
  12.      * Increases the capacity of and internally reorganizes this
  13.      * hashtable, in order to accommodate and access its entries more
  14.      * efficiently.  This method is called automatically when the
  15.      * number of keys in the hashtable exceeds this hashtable's capacity
  16.      * and load factor.
  17.      */
  18.     //扩容机制是原来的2倍+1
  19.     @SuppressWarnings("unchecked")
  20.     protected void rehash() {
  21.         int oldCapacity = table.length;
  22.         Entry<?,?>[] oldMap = table;
  24.         // overflow-conscious code
  25.         int newCapacity = (oldCapacity << 1) + 1;
  26.         if (newCapacity - MAX_ARRAY_SIZE > 0) {
  27.             if (oldCapacity == MAX_ARRAY_SIZE)
  28.                 // Keep running with MAX_ARRAY_SIZE buckets
  29.                 return;
  30.             newCapacity = MAX_ARRAY_SIZE;
  31.         }
  32.         Entry<?,?>[] newMap = new Entry<?,?>[newCapacity];
  34.         modCount++;
  35.         threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
  36.         table = newMap;
  38.         for (int i = oldCapacity ; i-- > 0 ;) {
  39.             for (Entry<K,V> old = (Entry<K,V>)oldMap[i] ; old != null ; ) {
  40.                 Entry<K,V> e = old;
  41.                 old = old.next;
  43.                 int index = (e.hash & 0x7FFFFFFF) % newCapacity;
  44.                 e.next = (Entry<K,V>)newMap[index];
  45.                 newMap[index] = e;
  46.             }
  47.         }
  48.     }

HashTable集合类存放空值元素的问题

  1. package javase.hashtable;
  3. import java.util.Hashtable;
  4. //HashTable类的k-v都不能为空，否则空指针异常
  5. //HashTable方法都带有Synchronized关键字，因此是线程安全的，线程安全有其他解决方案，
  6. //因此HashTable对线程的处理导致效率较低，使用较少
  7. //
  8. public class HashTableTest01 {
  9.     public static void main(String[] args) {
  10.         Hashtable<Integer, String> ht = new Hashtable<>();
  11.         ht.put(null,"zs");  //本行代码出现空指针异常
  12.         ht.put(12,null);    //本行代码也出现了空指针异常
  13.         System.out.println(ht);
  14.     }
  15. }

究其原因，是源代码有以下规则：

  1. /**
  2.      * Maps the specified <code>key</code> to the specified
  3.      * <code>value</code> in this hashtable. Neither the key nor the
  4.      * value can be <code>null</code>. <p>
  5.      *
  6.      * The value can be retrieved by calling the <code>get</code> method
  7.      * with a key that is equal to the original key.
  8.      *
  9.      * @param      key     the hashtable key
  10.      * @param      value   the value
  11.      * @return     the previous value of the specified key in this hashtable,
  12.      *             or <code>null</code> if it did not have one
  13.      * @exception  NullPointerException  if the key or value is
  14.      *               <code>null</code>
  15.      * @see     Object#equals(Object)
  16.      * @see     #get(Object)
  17.      */
  18.     public synchronized V put(K key, V value) {
  19.         // Make sure the value is not null
  20.         if (value == null) {
  21.             throw new NullPointerException();
  22.         }
  24.         // Makes sure the key is not already in the hashtable.
  25.         Entry<?,?> tab[] = table;
  26.         int hash = key.hashCode();
  27.         int index = (hash & 0x7FFFFFFF) % tab.length;
  28.         @SuppressWarnings("unchecked")
  29.         Entry<K,V> entry = (Entry<K,V>)tab[index];
  30.         for(; entry != null ; entry = entry.next) {
  31.             if ((entry.hash == hash) && entry.key.equals(key)) {
  32.                 V old = entry.value;
  33.                 entry.value = value;
  34.                 return old;
  35.             }
  36.         }
  38.         addEntry(hash, key, value, index);
  39.         return null;
  40.     }

Properties类

  1. package javase.hashtable.properties;
  3. /*
  4.     Properties是一个Map集合，继承自Hashtable，Properties的key和value
  5. 都是String类型，Properties被称为属性类对象
  6.  */
  8. import java.util.Properties;
  10. /**
  11.  * Properties类的常用方法：
  12.  * String    getProperty(String key)     用指定的键在此属性列表中搜索属性。
  13.  * String    getProperty(String key, String defaultValue)    用指定的键在属性列表中搜索属性。
  14.  * void    load(InputStream inStream)  从输入流中读取属性列表（键和元素对）。
  15.  * void    load(Reader reader)     按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
  16.  * Object    setProperty(String key, String value)   调用 Hashtable 的方法 put。
  17.  */
  18. public class PropertiesTest01 {
  19.     public static void main(String[] args) {
  21.         //需要掌握Properties的2个方法，一个存，一个取
  22.         Properties pro = new Properties();
  23.         pro.setProperty("username","root");
  24.         pro.setProperty("password","admin123");
  25.         String username = pro.getProperty("username");
  26.         System.out.println(username);   //root
  27.     }
  28. }

Collections工具类常用方法

  1. package javase;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  6. //java.util.Collection  集合接口
  7. //java.util.Collections 集合工具类，方便集合的操作
  8. public class CollectionsTest {
  9.     public static void main(String[] args) {
  11.         //ArrayList集合不是线程安全的
  12.         ArrayList<String> list = new ArrayList<>();
  13.         //变成线程安全的
  14.         Collections.synchronizedList(list);
  16.         //排序
  17.         //注意：对List集合中元素排序(限list)，需要保证List集合中的元素实现了Comparable接口
  18.         list.add("abc");
  19.         list.add("abf");
  20.         list.add("ahj");
  21.         list.add("bcx");
  22.         Collections.sort(list);
  23.         for (String s : list) {
  24.             //abc abf ahj bcx
  25.             System.out.print(s+" ");
  26.         }
  28.     }
  29. }