黑马程序员-java基础-集合

---<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ---

集合框架的出现，解决了数组的弊端

集合也是一个容器：存储

集合存储的是：对象，存储的内容都是引用数据类型，集合不存储基本数据类型

数组存储的是：对象，数组可以存储基本数据类型

集合中的长度是可变
数组的长度是固定

JAVA中的万物皆对象，集合的出现，存储对象
数据多了存数组，对象多了存集合

数组和集合的共性： 容器存储
不同：
  1. 集合变长
            数组定长
            
  2. 集合存储对象
            数组基本类型，对象都存储

  3. 数组存储的类型单一化
            集合存储的类型可以是多个


集合框架中的继承体系关系:

 Collection 接口 (集合)
   |-- List extends Collection 接口 (列表)
     |-- ArrayList  implements List  类 (数组列表)
     |-- LinkedList implements List类 (链表)
     |-- Vector     implements List 类 (数组列表)
     
   |-- Set extends Collection   接口 (集)
     |-- HashSet implements Set   类 (哈希表)
        |-- LinkedHashSet extends HashSet  类 (基于链表的哈希表)
     |-- TreeSet implements Set   类 (红黑树)
     
 
 Iterator 接口 (迭代器)
   |-- ListIterator 接口 (列表迭代器)
   
 
 Map  接口 (映射键值对)  -- 内部接口 Entry
   |-- HashMap implements Map   类 (哈希表)
       |-- LinkedHashMap extends HashMap 类 (基于链表的哈希表)
   |-- TreeMap implements Map   类 (红黑树)
   |-- Hashtable implements Map 类 (哈希表)
       |-- Properties extends Hashtable  类 (哈希表)


=============================================================================
Collection 
 方法
 |-- add 存对象
 |-- size 获取长度
 |-- contains 判断集合是不是包含对象
 |-- iterator 获取迭代器方法

Iterator

迭代器： 获取出集合中存储对象的方式，简称，迭代，遍历
  Collection接口中，定义了一个方法 iterator() 既然接口中定义了方法，下面所有的小弟都有这个方法
  List Set ArrayList LinkedList Vector HashSet TreeSet
  
  方法含义： iterator() 获取迭代器对象 返回值类型  Iterator iterator()
   Iterator 是一个接口，iterator方法返回了一个接口的类型，方法返回的肯定是接口的实现类的对象
   
     Iterator接口中的方法 只有三个方法
     boolean hasNext() 判断集合中有没有下一个元素，如果有返回true
     Object  next()    获取集合中的下一个元素
     void    remove()  移除集合中的元素
      
 Iterator iterator() 返回的是 迭代器接口Iterator的实现类的对象? 实现类是谁
 但是这个实现类，实现了Iterator接口，重写了 三个方法
 
 由于集合每个子类本身的特点不同，存储元素的方式不同，获取方式也就随之不同
 因此规定一个接口，不管获取的方式是什么，必须满足接口中的三个方法
 将Iterator接口的实现类，定义在了集合的内部类，内部类实现了Iterator接口，重写了三个抽象方法
 
  interface Iterator{
    boolean hasNext();
    Object next();
    void remove();
 }
   Iterator it = new ArrayList().iterator();
 public class ArrayList extends AbstractList implements List{
 //Collection中定义了方法iterator() 实现类ArrayList必须重写这个方法
 public Iterator iterator(){
    return new Itr();
 }
  
 //定义了一个内部类，实现了Iterator接口
 private class Itr implements Iterator{
    public  boolean hasNext(){ return false;} 
        public  Object next(){return null;}
        public  void remove(){}
 }
 }


 
注意事项:
   没有元素了，不能继续next
   迭代中不要使用集合方法修改长度，否则出现并发修改异常
   一次迭代中不允许多次next
================================================================================

1. List 派系

    特点:

    |-- 有序集合，存储和取出顺序一致
    |-- 有索引的集合

    |-- 允许重复元素的集合

list集合的一些方法:

/*
* List subList(int formIndex ,int toIndex)
* 获取列表中的一部分，包含头，不包含尾
*/
public static void method_5(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
list.add("abc5");
list.add("abc6");
System.out.println(list);
//获取1-4索引的元素
List list2 = list.subList(1, 4);
System.out.println(list2);
}

/*
* Object set(int index ,Object o)
* 修改指定索引上的元素
* 返回，修改之前的
*/
public static void method_4(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
//修改1索引上的元素，修改成 false
Object o = list.set(1, false);
System.out.println(o);
System.out.println(list);
}

/*
* Object remove(int index)
* 移除指定索引上的元素
* 返回值，返回被删除的哪个元素
*/
public static void method_3(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//移除0索引
Object o = list.remove(0);
System.out.println(o);
System.out.println(list);
}

/*
*  Object get(int index)
*  根据索引，获取指定索引上的元素
*/
public static void method_2(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
//get方法，获取第1索引上的元素
/*Object o = list.get(11);
System.out.println(o);*/
//像遍历数组一样，遍历集合
for(int x = 0  ; x < list.size() ;x++ ){
System.out.println(list.get(x));
}
}

/*
* boolean addAll(int index, Collection c)
* 在集合的指定索引上，添加另一个集合的元素
*/
public static void method_1(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");

List list2 = new ArrayList();
list2.add(123);
list2.add(456);

//在list集合的2索引上，将list2的全部元素添加进去
list.addAll(2, list2);
System.out.println(list);

}


/*
* boolean add(int index , Object o)
* 在指定的索引上添加对象
*/
public static void method(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
//在第3索引上，添加元素www.baidu.com
list.add(5, "www.baidu.com");
System.out.println(list);
}
}
/*
 * List接口的特有迭代器
 * List接口中，定义了一个方法 listIterator()
 *   ArrayList LinkedList Vector 实现类，重写了 listIterator()方法
 *   返回了一个接口类型  ListIterator 的实现的类对象
 *   ListIterator 特有迭代器
 *     add(Object o)迭代中，添加元素到集合
 *     remove() 迭代中，移除集合中的元素
 *     set(Object o )迭代中，修改集合中的元素
 *   
 *  
 *   ListIterator 迭代器 逆向遍历列表
 *     hasPrevious() 和  hasNext()
 *     previous() 和  next()
 *   迭代中，不允许使用集合的方法，改变集合长度
 */
import java.util.*;
public class ListDemo {
public static void main(String[] args) {
method_2();
}
/*
* List集合特有迭代器的逆向遍历
*/
public static void method_2(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");

ListIterator lit = list.listIterator();
while(lit.hasNext()){
System.out.println(lit.next());
}
System.out.println("===================");

while(lit.hasPrevious()){
System.out.println(lit.previous());
}
System.out.println("=================");
for(int x = list.size()-1 ; x >= 0 ; x--){
System.out.println(list.get(x));
}
}


/*
* List集合，迭代中，修改元素
* 迭代器方法set 修改集合元素
* 修改的元素是，next()方法获取到哪个元素，修改的是哪个元素
*/
public static void method_1(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
// 使用集合方法 listIterator获取List特有迭代器对象
ListIterator lit = list.listIterator();
//迭代中，如果集合中有 abc3这个元素，修改成大写的 ABC3
while(lit.hasNext()){
Object o = lit.next();
if("abc3".equals(o))
//修改方法，A使用的迭代器方法
lit.set("ABC3");
}
System.out.println(list);
}



/*
* List集合，在使用特有迭代器的过程中，添加一个元素到集合
* 添加的方法，不允许使用集合的，必须使用迭代器
* add方法的添加位置，是在next()方法获取到的元素的下一个元素上
*/
public static void method(){
List list = new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
//调用集合方法 listIterator获取List集合的特有迭代器对象
//迭代中。判断集合中有没有 abc2对象，如果有添加一个 QQ 
ListIterator lit = list.listIterator();
while(lit.hasNext()){
Object o = lit.next();
if("abc2".equals(o))
lit.add("QQ");
//System.out.println(lit.next());
}
System.out.println(list);
}
}
1-1 ArrayList
   集合的自身特性
    |-- 底层数组结构，可变长度数组，默认10个，增长量50%
    |-- 查询快，增删慢

    |-- 线程不安全集合，运行速度快

  案例:

/*
* List集合嵌套遍历
*/
public static void test2(){
ArrayList<String> array1 = new ArrayList<String>();
    ArrayList<String> array2 = new ArrayList<String>();
    array1.add("e");
    array1.add("d");
    array2.add("a");
    array2.add("f");
    //集合array存储 array1和array2两个集合
    ArrayList<ArrayList<String>> array = new ArrayList<ArrayList<String>>();
    array.add(array1);
    array.add(array2);
    
    //迭代集合
    Iterator<ArrayList<String>> it = array.iterator();
    while(it.hasNext()){
    //明确 it.next获取出来的是什么，获取的就是集合array存储的内容
    //next方法获取到的是ArrayList集合
    ArrayList<String> list = it.next();
    Iterator<String> listIt = list.iterator();
    while(listIt.hasNext()){
    //next方法获取的就是，；里面集合存储字符串
    System.out.println(listIt.next());
    }
    }
}

  
1-2 LinkedList
   集合的自身特性
    |-- 底层链表结构，采用对象记录地址存储方式
    |-- 查询慢，增删快

    |-- 线程不安全集合，运行速度快

 /*
 * LinkedList集合，也是List接口实现类
 *   有序，索引，重复
 * 
 * LinkedList自身特性
 *   底层数据结构，链表结构 -- 对象的地址记录方式存储
 *   查询速度慢，增删快
 *   线程不安全，运行速度快
 *   
 * 单独操作链表的开头和结尾
 */
import java.util.*;
public class LinkedListDemo {
public static void main(String[] args) {
method_1();
}

/*
* LinkedList特有功能
* Object removeFirst() 获取并移除链表开头
* Object removeLast()  获取并移除链表结尾
*/
public static void method_2(){
LinkedList link = new LinkedList();
link.add("abc1");
link.add("abc2");
link.add("abc3");
link.add("abc4");
//移除链表开头
System.out.println(link.removeFirst());
//移除链表结尾
System.out.println(link.removeLast());

System.out.println(link);
}


/*
* LinkedList特有功能
* Object getFirst()获取链表开头
* Object getLast()获取链表的结尾
*/
public static void method_1(){
LinkedList link = new LinkedList();
link.add("abc1");
link.add("abc2");
link.addFirst("www");
link.addLast("OK");
link.add("abc3");
link.add("abc4");


System.out.println(link.getFirst());
System.out.println(link.getLast());
}


/*
* LinkedList特有功能
* addFirst(Object o)在链表的开头插入对象
* addLast(Object o)在链表的结尾插入对象
*/
public static void method(){
LinkedList link = new LinkedList();
link.add("abc");
link.add("bcd");

//在链表的开头插入元素
link.addFirst("china");
//在链表的结尾插入元素
link.addLast("usa");
System.out.println(link);

System.out.println("===========");

LinkedList link2 = new LinkedList();
link2.addFirst("abc1");
link2.addFirst("abc2");
link2.addLast("QQ");
link2.addFirst("abc3");
link2.addFirst("abc4");
System.out.println(link2);
}




}

1-3 Vector
   集合自身特点
    |-- 底层数组结构，可变长度，默认容量10个，增长100%
    |-- 查询快，增删慢

    |-- 线程安全集合，运行速度慢

/*

 *  Vector出现于JDK1.0版本

 *  集合框架出现于JDK1.2版本， Vector从1.2版本开始，改进为实现List接口
 *  但是类名不能改 (VectorList) 必须做到版本的向下兼容
 *  在没有集合框架之前，存储对象只能依赖Vector，有了集合后，Vector被ArrayList取代，
 *  
 */
public class VectorDemo {
public static void main(String[] args) {
method_1();
}
/*
* Vecor自身获取方式，向量枚举，看成是迭代器的前身
* Enumeration<E> elements() 等同于  Iterator iterator()
* boolean hasMoreElements() 等同于 Iterator  hasNext()
       nextElement() 等同于 Iterator  next()
*/
public static void method_1(){
Vector v = new Vector();
v.add(new Student("a",10));
v.add(new Student("b",12));

Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}

==============================================================================
1. Set 派系
   自身特性
   |-- 无序
   |-- 没有索引
   |-- 不允许重复


1-1 HashSet
   |-- 底层是哈希表结构
   |-- 查询快
   |-- 线程不安全的集合，运行速度快
   |-- 凡是存储到哈希表集合中的对象，必须实现hashCode equals方法
       保证对象的唯一性
1-2 TreeSet
   |-- 底层红黑树
   |-- 对存储的元素进行排序
     |-- 依据对象的自然顺序
        存储的对象，实现java.lang.Comparable接口，重写compareTo方法
     |-- 自定义比较器，集合自己具备比较性
        定义类，实现 java.util.Comparator接口，重写compare方法
创建TreeSet集合的时候，比较器对象传递到集合构造方法
===============================================================================
1. Map
  |-- 映射键值对
  |-- 集合中的键是唯一性
  |-- 每个键只能映射一个值


   Map 接口方法
  |-- put 存键值对
  |-- get 根据键获取值
  |-- size 键值对的个数
  |-- containsKey 判断集合中有没有这个键
1-1 HashMap
   自身特性
   |-- 底层哈希表
   |-- 线程不安全集合，运行速度快
   |-- 允许存储null值，null键

   |-- 保证存储到键对象唯一性，对象实现hashCode equals方法

案例:

import cn.itcast.student.Student;
public class HashMapDemo {
public static void main(String[] args) {
test1();
}
/*
*   HashMap存储和取出练习
*   键是Student类，值是String
*/
public static void test1(){
HashMap<Student,String> map = new HashMap<Student, String>();
map.put(new Student("zhangsan",21), "昌平");
map.put(new Student("lisi",19), "海淀");
map.put(new Student("lisi",19), "海淀");
map.put(new Student("wangwu",20), "朝阳");
map.put(new Student("zhaoliu",18), "密云");
//keySet获取
//集合方法keySet 所有的键，存储Set集合
Set<Student> set = map.keySet();
//迭代Set集合
Iterator<Student> it = set.iterator();
while(it.hasNext()){
//next获取的是Set集合，中的Student，Map中的键
Student key = it.next();
//集合方法get 通过键获取值
String value = map.get(key);
System.out.println(key+"..."+value);
}
System.out.println("============");
//entrySet方法获取
//集合方法 entrySet将，键值对关系对象Map.Entry存储Set集合
Set<Map.Entry<Student, String>> setEntry = map.entrySet();
//迭代Set集合
Iterator<Map.Entry<Student, String>>itEntry = setEntry.iterator();
while(itEntry.hasNext()){
//next方法获取出的是集合键值对关系对象Map.Entry
Map.Entry<Student, String> entry = itEntry.next();
//Map.Entry方法getKey  getValue
Student key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"..."+value);
}
}


/*
* HashMap存储和取出练习
* 键是String类，值是Student
*/
public static void test(){
HashMap<String,Student> map = new HashMap<String,Student>();
map.put("马尔代夫", new Student("zhangsan",20));
map.put("关岛", new Student("lisi",22));
map.put("海南岛", new Student("wangwu",21));
map.put("门头沟", new Student("zhaoliu",19));

//keySet获取
//集合方法keySet 获取所有的键，存储到Set集合
Set<String> set = map.keySet();
//迭代Set集合
Iterator<String> it = set.iterator();
while(it.hasNext()){
//next方法获取到是字符串，集合中的键
String key = it.next();
//集合方法 get 通过键获取值
Student value = map.get(key);
System.out.println(key+"..."+value);
}
System.out.println("=====================");

//entrySet获取
//集合方法entrySet 获取键值对关系对象接口Map.entry 存储到Set
Set<Map.Entry<String, Student>> setEntry = map.entrySet();
//迭代Set集合
Iterator<Map.Entry<String, Student>> itEntry = setEntry.iterator();
while(itEntry.hasNext()){
//next获取到是，集合中的键值对关系对象 Map.Entry
Map.Entry<String, Student> entry = itEntry.next();
//Map.Entry接口中的方法 getKey  getValue
String key = entry.getKey();
Student value = entry.getValue();
System.out.println(key+"..."+value);
}

}
}

1-2 TreeMap
   自身特性
    |-- 底层红黑树
    |-- 存储对键自然顺序的排序
    |-- 线程不安全集合，运行速度快


   排序方式
    |-- 依赖作为键的对象的自然顺序  Comparable

    |-- TreeMap构造方法中，传递比较器 Comparator

案例:

/*
 * 统计单个字母出现的次数
 */
import java.util.*;
public class TreeMapTest {
public static void main(String[] args) {
String s = "abbcaaceggWtTTwweDSDSgs";
//字符串变成字符数组
char[] arr = s.toCharArray();
//创建TreeMap的集合 键是字符，值是整型，写包装类
TreeMap<Character,Integer> map = new TreeMap<Character, Integer>();
//数组遍历
/*for(int x = 0 ; x < arr.length ; x++){

}*/
for(char c : arr){
//获取数组中的每个字符，字符当成键，到集合中获取值
Integer i = map.get(c);
//获取到的值 i 就有2个结果
if( i == null ){
//没找到，将键 1 存储到集合
map.put(c, 1);
}else{
//值++ 存回集合
i++;
map.put(c,i);
}
}
//输出需要的结果 a(1)
Set<Character> set = map.keySet();
Iterator<Character> it = set.iterator();
while(it.hasNext()){
Character c = it.next();
Integer value = map.get(c);
System.out.print(c+"("+value+")");
}
}
 1-3 Hashtable
   自身特性
    |-- 底层哈希表
    |-- 不允许存储null值，null键
    |-- 线程安全集合，运行速度慢


1-3-1 Properties
   自身特性
    |-- 底层哈希表，继承Hashtable
    |-- 线程安全的集合，运行速度慢
    |-- 可以和IO结合使用，实现数据的持久存储


   方法
    |-- setProperty 键值对存储集合

    |-- getProperty 根据键获取值

===========================================================================================

collections 集合工具类:

package cn.itcast.collections;
/*
 * java.util.Collection  接口
 * java.util.Collections 类
 *   集合操作的工具类，功能方便操作集合，里面的方法全静态
 *   直接类名调用
 * Collections类的方法概述
 *   sort 集合排序 - List
 *   reverseOrder  获取排序的比较器
 *   binarySearch 集合折半查找 - List
 *   max  获取集合中的最大值
 *   reverse 反转集合
 *   shuffle 集合中的元素 随机排列       洗牌
 *   
 * 面试方法：
 *   常用的集合都是线程不安全集合，如何将线程不安全集合变成线程安全集合呢
 *   Collections工具类方法，就可以将线程不安全集合，变成安全集合
 *   方法名的开头  synchronized
 */
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;


import cn.itcast.Map.StudentComparator;
import cn.itcast.student.Student;
public class CollectionsDemo {
public static void main(String[] args) {
method_7();
}
/*
* 对集合随机排列
* shuffle(List)
*/
public static void method_7(){
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(5);
list.add(8);
list.add(11);
list.add(16);
list.add(19);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
}

/*
* 反转集合方法
* reverse(List)
*/
public static void method_6(){
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(5);
list.add(8);
list.add(11);
list.add(16);
list.add(19);
System.out.println(list);
Collections.reverse(list);
System.out.println(list);
}

/*
* 获取最大值方法
* max 根据对象自然顺序获取最大值
*/
public static void method_5(){
List<String> list = new ArrayList<String>();
list.add("uhygtf");
list.add("agsdaf");
list.add("etrgf");
list.add("e4rw");

String max = Collections.max(list);
System.out.println(max);
}

/*
* 集合折半查找
* int binarySearch (List , Object key)
* 找不到，返回-插入点-1
*/
public static void method_4(){
List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(5);
list.add(8);
list.add(11);
list.add(16);
list.add(19);

System.out.println(list);

int index =  Collections.binarySearch(list, 17);
System.out.println(index);
}


/*
* 获取比较器的方法
* Comparator reverseOrder(Comparator c)
* 传递一个比较器，方法结果返回一个比较器，结果逆转了传递的比较器的顺序
*/
public static void method_3(){
List<Student> listStu = new ArrayList<Student>();
listStu.add(new Student("jack",21));
listStu.add(new Student("white",31));
listStu.add(new Student("amen",31));
listStu.add(new Student("tom",5));
listStu.add(new Student("jerry",2));
System.out.println(listStu);

//使用工具类Collections静态方法reverseOrder 逆转自定义比较器
//Comparator com =Collections.reverseOrder(new StudentComparator());

Collections.sort(listStu,Collections.reverseOrder(new StudentComparator()));
System.out.println(listStu);
}



/*
* 获取比较器的方法
*  Comparator reverseOrder() 返回是比较器
* 这个比较器，逆转了对象中的自然顺序，逆转Comparable的顺序
*/
public static void method_2(){
List<Student> listStu = new ArrayList<Student>();
listStu.add(new Student("jack",21));
listStu.add(new Student("white",31));
listStu.add(new Student("amen",31));
listStu.add(new Student("tom",5));
listStu.add(new Student("jerry",2));

System.out.println(listStu);
//调用工具类Collections静态方法 reverseOrder获取比较器
//Comparator com = Collections.reverseOrder();
Collections.sort(listStu,Collections.reverseOrder());

System.out.println(listStu);
}



/*
* 对List集合排序
* Collections.sort(list,Comparator)
* 传递比较器，按照比较进行排序
*/
public static void method_1(){
List<Student> listStu = new ArrayList<Student>();
listStu.add(new Student("jack",21));
listStu.add(new Student("white",31));
listStu.add(new Student("tom",5));
listStu.add(new Student("jerry",2));
System.out.println(listStu);

//调用工具类的sort方法，传递比较器
Collections.sort(listStu,new StudentComparator());
System.out.println(listStu);
}


/*
* 对List集合进行排序
* Collections.sort(list)
* List存储的是对象，按照自然顺序排序
*/
public static void method(){
List<String> list = new ArrayList<String>();
list.add("abeggh");
list.add("aweds");
list.add("xcvc");
list.add("er");
list.add("jhrge");

System.out.println(list);

Collections.sort(list);

System.out.println(list);


List<Student> listStu = new ArrayList<Student>();
listStu.add(new Student("jack",21));
listStu.add(new Student("white",31));
listStu.add(new Student("tom",5));
listStu.add(new Student("jerry",2));
System.out.println(listStu);
Collections.sort(listStu);
System.out.println(listStu);
}
}