集合

一、集合

　　集合特点: 长度可变，只能存储引用类型

  集合与数组的区别

    数组：长度固定，可以存储基本数据类型，也可以存储引用类型，数组存储的数据类型一致

    集合：长度可变，只能存储引用类型，引用类型可以为不同类型的对象

　　Collection集合(功能)：

    添加功能：

 public booleam add(Object obj):向集合中添加一个元素

 public boolean addAll(Collection c):向集合中添加一个集合的元素

    删除功能：

 public void clear():删除集合中所有元素

 public boolean remove(Object obj):删除指定元素

 public boolean removeAll(Collection c)：删除集合中指定的集合元素

    判断功能：

 public boolean isEmpty()：判断集合是否为空

 public boolean contains(Object obj):判断集合中是否存在指定的元素

 public boolean containsAll(Collection c):判断集合中是否存在指定集合中的元素

    遍历功能：

 Iterator iterator():获取集合中每一个元素

    长度功能：

 public int size():获取集合元素个数

    交集功能：

 public boolean retainAll(Collection c):判断两个集合中是否有相同元素

    转换功能：

 public Object[] toArray():转集合为数组

　　集合所有带All方法：

 public boolean addAll(Collection c)：向集合中添加一个集合的元素

 public boolean removeAll(Collection c)：从集合中删除指定集合的元素

 public boolean containsAll(Collection c)：判断集合中是否存在指定集合中的元素

 public boolean retainAll(Collection c)：判断两个集合中是否有相同的元素

  Iterator(迭代器)：

 成员方法：

 public Object next()：获取元素，并自动移动到一个位置等待获取

 public boolean hasNext()：判断迭代器中是否还有元素

　　List(特点)：元素有序(存储顺序与取出顺序一致)，元素可重复

　　List(功能)：

    添加功能：

 public void add(int index,Object obj)：在指定位置添加元素

    删除功能：

 public Object remove(int index)：删除指定索引处的元素，并把删除的元素返回

    修改功能：

 public Object set(int index,Object obj)：把指定索引处的元素修改为指定的值，返回修改前的值

    获取功能：

 public int indexOf(Object o)：返回指定元素在集合中第一次出现的索引

 public Object get(int index)：获取指定索引处的元素

 ListIterator listIterator()：列表迭代器
    截取功能：

 public List subList(int fromIndex,int toIndex)：截取集合

    　　size()、get()方法遍历ArrayList集合

 public Object get(int index)：获取指定索引处的元素

 public int size()：获取集合元素个数

public class ListTest {
 public static void main(String[] args) {
  // 创建集合对象
  List list = new ArrayList();

  // 添加元素
  list.add("hello");
  list.add("world");
  list.add("java");

  // 结合size()和get()对集合进行遍历
  for (int x = 0; x < list.size(); x++) {
   String s = (String) list.get(x);
   System.out.println(s);
  }
 }
}
　　列表迭代器(ListIterator)--并发修改异常(产生与解决方法：全部通过迭代器操作，全部通过集合操作)

    并发修改异常(ConcurrentModificationException)

      产生原因：在我们通过迭代器遍历元素的过程中，又通过集合操作了元素，这种情况下会产生并发修改异常

           因为迭代器是依赖于集合存在的，在集合发生了变化，迭代器也应该做出相应的变化，但在实际情况中

    集合发生了变化，而迭代器还是之前的迭代器，所以就产生了并发修改异常

      解决方法：

 A:全部通过迭代器操作：元素出现在刚遍历到的那个元素后面
  
  采用列表迭代器(ListIterator)，通过列表迭代器对集合进行操作　　

　　    B:全部通过集合操作：元素出现在集合中最后一个位置处

  采用普通for遍历集合，通过集合对集合进行操作(结合size()和get()方法遍历)

    List接口三个实现类特点：

 ArrayList：底层数据结构为数组，查询快，增删慢，线程不安全，效率高

 Vector：底层数据结构为数组，查询快，增删慢，线程安全，效率低

 LinkedList：底层数据结构为链表，查询慢，增删快，线程不安全，效率高

    ArrayList存储字符串并遍历(迭代器遍历(hasNext()与next()方法)与普通for循环遍历(结合size()与get()方法))

　　ArrayList存储自定义对象并遍历(迭代器遍历(hasNext()与next()方法)与普通for循环遍历(结合size()与get()方法))

　　ArrayList存储多个字符串并实现去除重复元素

　　ArrayList存储学生对象并实现去除重复元素(在自定义对象所属类中重写equals()方法，在main()方法中判断，如下：)
@Override
 public boolean equals(Object obj) {
  //提高效率
  if(this==obj){
   return true;
  }
  //提高健壮性
  if(!(obj instanceof Student)){
   return false;
  }
  //向下转型
  Student s=(Student)obj;
  return this.name.equals(s.name)&&this.age==s.age;
 }

　　Vector(功能)：

      添加功能：

 public void addElement(Object obj)：添加元素

      获取功能：

 public Object elementAt(int index)：获取指定索引处元素

 public Enumeration elements()：获取集合中每一个元素
  boolean hasMoreElements()：判断迭代器中是否还有元素
  Object nextElement()：获取元素，并自动移动到下一个元素位置等待

      长度功能：

 public int size()：获取集合元素个数

　　LinkedList(功能)：

      添加功能：

 public void addFirst(Object c)：将指定元素添加到集合开头

 public void addLast(Object c)：将指定元素添加到集合结尾

      获取功能：

 public Object getFirst()：获取集合开头元素

 public Object getLast()：获取集合结尾元素

       删除功能：

 public Object removeFirst()：删除集合开头元素

 public Object removeLast()：删除集合结尾元素

　　通过LinkedList模拟栈数据结构(栈数据结构特点：先进后出)

/*
 * 自定义栈集合。
 */
public class MyStack {
 private LinkedList link;

 public MyStack() {
  link = new LinkedList();
 }

 public void add(Object obj) {
  link.addFirst(obj);
 }

 public Object get(int index) {
  return link.get(index);
 }

 public int size() {
  return link.size();
 }
}
public class LinkedListTest {
 public static void main(String[] args) {
  // 创建集合对象
  MyStack ms = new MyStack();

  // 创建并添加元素
  ms.add("hello");
  ms.add("world");
  ms.add("java");
  //遍历集合
  for (int x = 0; x < ms.size(); x++) {
   String s = (String) ms.get(x);
   System.out.println(s);
  }
 }
}

　  泛型：

 任意的类型。是一种把明确数据类型的工作放在了创建对象或者调用方法时进行的特殊的类型

 格式：<数据类型>
 
 泛型的作用：解决黄色警告线问题；把运行期间的类型转换异常提前到了编译期间；优化程序设计

    增强for循环：

 格式：for(数组或者Collection集合中元素类型 变量名：数组或者Collection集合对象)
              {
                使用变量名即可。
       }

 增强for是用来替代迭代器的。不能在用增强for的时候，用集合对象对集合进行改变。

    泛型类：把泛型定义在类上
public class Tool2<QQ> {
 public void show(QQ qq){
  System.out.println(qq);
 }
}
public class Tool2Test {
 public static void main(String[] args) {
  Tool2<String> t=new Tool2<String>();
  t.show("hello");
  Tool2<Integer>t2 = new Tool2<Integer>();
  t2.show(10);
 }
}
    泛型方法：把泛型定义在方法上
public class Tool {
 public <QQ>void show(QQ qq){
  System.out.println(qq);
 }
}
public class ToolTest {
 public static void main(String[] args) {
  Tool t = new Tool();
  t.show("hello");
  t.show(10);
 }
}

    泛型接口：把泛型定义在接口上
public interface Inter<BMW> {
 public abstract void show(BMW bmw);
}
/*
* 第一种方式，在创建实现类对象之前就已经知道添加的数据类型
 */
//public class InterImpl implements Inter<String> {
//
// @Override
// public void show(String bmw) {
//  System.out.println(bmw);
// }
// 
//}
/*
 * 在创建实现类对象的时候才知道要添加数据的类型
 */
public class InterImpl<BMW> implements Inter<BMW>{

 @Override
 public void show(BMW bmw) {
  System.out.println(bmw);
 }
}
public class InterTest {
 public static void main(String[] args) {
  //第一种实现方式
//  InterImpl ii = new InterImpl();
//  ii.show("hello");
  //第二种实现方式
  InterImpl<String> ii = new InterImpl<String>();
  ii.show("hello");
 }
}

  Set(特点)：元素无序，元素唯一

　　HashSet(存储字符串并遍历)

    HashSet(存储自定义对象并遍历--在Student类中自动生成HashCode()和equals()方法)

　　TreeSet(存储字符串并遍历--排序与唯一)

　　TreeSet(存储自定义对象，1、自定义对象所属类实现Comparable接口并按实际要求重写compareTo()方法；2、比较器接口Comparator,使用的是匿名内部类的做法并按实际要求重写compareTo()方法)

　　TreeSet存储Integer类型的数据，保证唯一和排序

　　Collections(功能)：

        排序：
 public static void sort(List list)

 二分查找：

 public static<T> int binarySearch(List list, T key)

 反转：

 public static void reverse(List list)

 最大值：

 public static T max(Collection coll)

 随机置换：

 public static void shuffle(List list) 

    Collection与Collections的区别:

 Collection:是Collection集合的顶层接口，定义了Collection集合的共性方法。

 Collections:是一个类，定义了针对Collection集合操作的功能。有排序，查找，反转，最大值，随机置换等。

　　Map定义：

 是一个键值对形式的集合，最大优点是体现了对应关系，它的数据不再是单个的，必须同时有键和值组成

    Map与Collection区别：

 Map：是(键值对)双列形式的集合，键唯一，值可重复

 Collection:是单列值的集合，Collection的List:可重复，Collection的Set：唯一

    Map功能：

 增加功能：
   
    public V put(K key,V value)：当key在集合中不存在时，添加元素；当key在集合中存在，替换元素

 删除功能：

    public void clear():清除所有键值对数据

    public V remove(Object key):根据指定的键删除键值对

 判断功能：

    public boolean containsKey(Object key):判断是否包含指定的键

    public boolean containsValue(Object value):判断是否包含指定的值

    public boolean isEmpty():判断集合是否为空

 获取功能：

    public Set<Map.Entry<K,V>> entrySet():键值对对象的集合

    public Object get(Object key):根据键获取值

    publicf Set<K> keySet():所有键的集合

    public Collection<V> values():所有值的集合

 长度功能：

    public int size():获取集合元素个数
 

　　Map集合遍历(方式一：Set<K> keySet():所有键的集合，Object get(Object key)根据键获取值  Collection<V> values()：所有值的集合)

　　Map集合遍历(方式二：Set<Map.Entry<K,V>> entrySet():键值对对象的集合 String getKey():获取键 String getValue()：获取值)

　　HashMap存储键和值，并遍历(键：String,值：String)

　　HashMap存储键和值，并遍历(键：String,值：Student)(Student类中自动生成hashCode()和equals()方法)

　　HashMap存储键和值，并遍历(键：Student,值：String)(Student类中自动生成hashCode()和equals()方法)

　　TreeMap存储String类型的键和值

　  TreeMap存储自定义对象并遍历(键：Student,值：String):

 (两种方式：Student类实现Comparable接口并按实际要求重写compareTo()方法；

 比较器接口Comparator--匿名内部类的做法并按实际要求重写compareTo()方法)

    Hashtable与HashMap的区别：

 Hashtable:线程安全，效率低；不允许null键和值

 HashMap:线程不安全，效率高；允许null键和值

    HashMap双嵌套：
/*
 *  czbk:
 *   yr 预热班
 *   jy 就业班
 * 预热班:
 *   01 zhangsan
 *   02 lisi
 * 就业班:
 *   01 wangwu
 *  02 zhaoliu
 */
public class HashMapDemo {
 public static void main(String[] args) {
  //创建czbk对象
  HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();
  //创建预热班对象并添加元素
  HashMap<String,String> yr = new HashMap<String,String>();
  yr.put("01", "zhangsan");
  yr.put("02", "lisi");
  //创建就业班对象并添加对象
  HashMap<String,String> jy = new HashMap<String,String>();
  jy.put("01", "wangwu");
  jy.put("02", "zhaoliu");
  //添加
  czbk.put("yr",yr);
  czbk.put("jy", jy);
  //遍历
  Set<String> set=czbk.keySet();
  for(String key:set){
   HashMap<String,String> value =czbk.get(key);
   System.out.println(key);
   Set<String> s=value.keySet();
   for(String k:s){
    String v=value.get(k);
    System.out.println("\t"+k+"****"+v);
   }
  }
 }
}

    TreeMap获取每一个字母出现的次数：

/*
 * "cbxzbvavdvgd"获取字符串中，每一个字母出现次数："a(1)b(2)c(1)d(2)g(1)v(3)x(1)z(1)"
 * 思路：
 * A:把字符串变成字符数组。
 * B:定义一个TreeMap集合。Character做键，Integer做值。
 * C:遍历字符数组，获取到每一个字符。
 * D:拿到该字符，到TreeMap集合中找对应的值
 * E:根据返回值是否为null
 *   是：存储，把次数记录为1
 *   否：把数据++，然后重写存储
 * F:把TreeMap的数据拼接成一个字符串。
 */
public class TreeMapTest {
 public static void main(String[] args) {
  String s = "cbxzbvavdvgd";

  // 把字符串变成字符数组。
  char[] chs = s.toCharArray();

  // 定义一个TreeMap集合。Character做键，Integer做值。
  TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();

  // 遍历字符数组，获取到每一个字符。
  for (Character ch : chs) {
   // 拿到该字符，到TreeMap集合中找对应的值
   Integer i = tm.get(ch);

   // 根据返回值是否为null
   // 是：存储，把次数记录为1
   // 否：把数据++，然后重写存储
   if (i == null) {
    tm.put(ch, 1);
   } else {
    i++;
    tm.put(ch, i);
   }
  }

  // System.out.println(tm);

  // 把TreeMap的数据拼接成一个字符串。
  StringBuilder sb = new StringBuilder();
  Set<Character> set = tm.keySet();
  for (Character ch : set) {
   Integer i = tm.get(ch);
   sb.append(ch).append("(").append(i).append(")");
  }

  String result = sb.toString();
  System.out.println(result);
 }
}