第七章 集合类

第七章 集合类

java.util.*

7.1 集合的概念

集合作为JAVA中数据存储介质，和数组不同的是：

1. 集合中的元素类型可以不一样（默认每个元素Object）

2. 集合的大小可变，可以扩容的，方便增删改

7.2 集合的分类（重点）

系列1：

Collection接口： 存储值

List子接口： 有下标，0开始，顺序

ArrayList 实现类 线性存储结构，元素挨着， 适合查询，不适合更新，线程不安全，效率高，不同步，速度快

LinkedList 实现类 链式存储结构，元素不挨着，适合更新，不适合查找

Vector 实现类 线程安全，效率低，同步

Set子接口： 没有下标，不能保证顺序，吞并重复元素

HashSet 实现类 ： 哈希表存储 自动去重

TreeSet 实现类 ： 红黑树存储 可以自然排序

系列2：

Map接口：存键值对

HashMap 实现类： 线程不安全，效率高，不同步，速度快

Hashtable 实现类： 线程安全，效率低，同步

TreeMap 实现类 ： 自然排序

7.3 ArrayList集合

可变容量的数组，随着元素的增加而扩充容量，线性存储结构，List的实现类，该类是有下标，下标从0开始。

底层有容量判断机制，自动扩容。

构造方法:

 new ArrayList(); //空构造
 new ArrayList(Collection c);//使用多态构建集合

方法：

方法名	含义	返回值
add(元素)	尾部追加	布尔
add(下标,元素)	在下标前插入元素	无
size()	集合大小	int
remove(下标)	根据下标删除元素	E
remove(元素)	根据元素删除	boolean
get(下标)	根据下标获得一个元素	E
set(下标，元素)	根据下标修改元素	无
clear()	清除集合
indexOf()/lastIndexOf()	元素查找	int -1

注意：当使用remove()的时候，传入参数int型，默认认为是下标。

集合的方法案例：

 public class TestList1 {
     public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         //追加元素
         list.add(20);
         list.add(40);
         list.add(60);
         list.add(80);
         
         //在60前插入88
         //list.add(2,88);       
         //打印大小
         //System.out.println(list.size());
         //list.remove(20);  下标20
         //装箱删除
         //list.remove(new Integer(20));
         //该类覆盖toString()
         //System.out.println(list.toString());
         //System.out.println(list.get(0));
         //修改
         list.set(list.size() - 1, 100);
 }

集合的遍历：

         //遍历集合 get()获得元素
         for (int i = 0; i < list.size(); i++) {
             System.out.println(list.get(i));
         }
         //foreach
         for (Integer a : list) {
             System.out.println(a);
         }

7.4 HashSet集合

没有下标的线性集合，不能保证元素的顺序，会自动去重，内存： 哈希表

构造方法：

 new HashSet();
 new HashSet(Collection c);

方法：

方法名	含义	返回值
add()	尾部增加，不能插入
remove(元素)	删除对应元素
size()	大小
iterator()	返回该集合的迭代器（专门用于Collection元素遍历）

迭代器接口：Iterator<E> 很多集合实现类都实现了该接口

方法	含义	返回值
hasNext()	是否有迭代元素	boolean
next()	取出下一个元素	E

案例：

 public class TestSet1 {
     public static void main(String[] args) {
         Set<String> set = new HashSet<>();
         
         set.add("jack");
         set.add("rose");
         set.add("tom");
         //重复元素无法添加
         set.add("jack");
         //删除
         //set.remove("rose");
         set.remove("ys");
         System.out.println(set.size());
         System.out.println(set);
     }
 }

合并去重：

 public class TestSet2 {
     public static void main(String[] args) {
         //两个数组合并 且去掉重复
         int[] a = {12,45,23,77,83,45,7};
         int[] b = {42,65,23,57,88};
         
         //创建HashSet
         HashSet<Integer> set = new HashSet<>();
         
         for (int i = 0; i < a.length; i++) {
             set.add(a[i]);
         }
         for (int i = 0; i < b.length; i++) {
             set.add(b[i]);
         }
         System.out.println(set);
     }
 }

set集合的遍历：

 //创建集合
 Set<String> set = new HashSet<>();
         //添加元素
         set.add("jack");
         set.add("rose");
         set.add("tom");
         set.add("ys");  
 //foreach 
 for (String s : set) {
         System.out.println(s);
 }
 //迭代器
 //获得集合的迭代器
 Iterator<String> it = set.iterator();
 //判断是否存在元素      
 while(it.hasNext()) {
     //获取并打印
     System.out.println(it.next());
 }

7.5 TreeSet集合

内存存储：红黑树（平衡二叉树）， 存储的元素会实现自然排序（得有排序算法）。

构造方法：

 new TreeSet();
 new TreeSet(Collection c);//传其他其他
 new TreeSet(Comparator c);//传入比较器，比较算法 

方法：

方法	含义	返回值
add(元素)	添加
size()	集合大小

Integer，String自动实现了排序算法：

 //      TreeSet<Integer> tree = new TreeSet<Integer>();
 //      
 //      tree.add(12);
 //      tree.add(72);
 //      tree.add(53);
 //      tree.add(8);
 //      tree.add(46);
         
 //      TreeSet<String> tree = new TreeSet<>();
 //      tree.add("apple");
 //      tree.add("peach");
 //      tree.add("banana");
 //      tree.add("orange");

水果类型需要自行添加比较算法：

比较机制：

Comparator 比较器，决定如何比较

Comparable 比较标志，实现了该接口的类能够自然排序。

 public class Fruit implements Comparable<Fruit>{
     private int fNo;
     private String fName;
     private double price;
     private int counts;
     public int getfNo() {
         return fNo;
     }
     public void setfNo(int fNo) {
         this.fNo = fNo;
     }
     public String getfName() {
         return fName;
     }
     public void setfName(String fName) {
         this.fName = fName;
     }
     public double getPrice() {
         return price;
     }
     public void setPrice(double price) {
         this.price = price;
     }
     public int getCounts() {
         return counts;
     }
     public void setCounts(int counts) {
         this.counts = counts;
     }
     public Fruit(int fNo, String fName, double price, int counts) {
         super();
         this.fNo = fNo;
         this.fName = fName;
         this.price = price;
         this.counts = counts;
     }
     
     public Fruit() {
         
     }
     @Override
     public String toString() {
         return "Fruit [fNo=" + fNo + ", fName=" + fName + ", price=" + price + ", counts=" + counts + "]";
     }
     @Override
     public int compareTo(Fruit o) {
         if(o.getPrice() == this.price) {
             return 0;
         }if(o.getPrice() > this.price) {            
             return -1;
         }else {
             return 1;
         }   
     }
 }
 ​

 TreeSet<Fruit> tree = new TreeSet<Fruit>();
         tree.add(new Fruit(1, "苹果", 5, 300));
         tree.add(new Fruit(2, "香蕉", 3, 100));
         tree.add(new Fruit(4, "法国香蕉", 3, 100));
         tree.add(new Fruit(3, "桃子", 8, 200));
         for (Fruit fruit : tree) {
             System.out.println(fruit);
         }