Java集合总结

集合体系：
   集合本身是一个存储的容器，必须使用集合存储对象
   遍历集合，取出对象
   集合自己的特性
   
Collection<E>所有集合类的父方法


List下面的是有序集合
Set下面的是无序集合


Collection接口中的方法是集合中所有实现类必须拥有的方法
必须使用实现类进行操作


java中三种长度表现形式
数组.length 属性返回值 int
字符串.length 方法返回值int
集合.size 返回值int


toArray() 集合中的元素，转成一个数组中的元素，集合转成数组
返回是一个存储对象的数组，数组存储的数据类型是Object
集合转数组
    private static void function_2() {
Collection<String> coll=new ArrayList<String>();
coll.add("AAA");
coll.add("BBB");
coll.add("CCC");

Object[] objs=coll.toArray();
for (int i = 0; i < objs.length; i++) {
System.out.println(objs[i]);
}
}


void clear()清空集合中的所有元素，集合容器本身存在
public static void function(){
  Collection<String> coll=new ArrayList<String>();
  coll.add("abc");
  coll.add("bcfd");
       
  System.out.println(coll);
  
  coll.clear();
  System.out.println(coll);
}

boolean contains(Object o) 判断对象是否存在于集合中，对象存在返回True
    public static void function_1() {
Collection<String> coll=new ArrayList<String>();
coll.add("QWE");
coll.add("123");
coll.add("ERT");
        
boolean b=coll.contains("123");
System.out.println(b);
}


迭代器表示取出元素的一种方法
集合中的迭代器是获取集合中元素的一种方式


接口Iterator:两个抽象方法
  boolean hasNext()判断集合中还有没有可以被取出的元素，如果有返回true
  next() 取出集合中的下一个元素
  
Iterator接口，找实现类
  Collection接口定义方法
      Iterator  iterator()
   ArrayList 重写方法iterator,返回了Iterator接口的实现类的对象
   使用ArrayList集合对象
    Iterator it=array.iterator（），运行结果就是Iterator接口的实现类的对象

//迭代是反复内容，使用循环实现，循环的条件是集合中没有元素
while (it.hasNext()) {
String a = it.next();
System.out.println(a);
}

迭代器遍历：
public class IteratorDemo {
   public static void main(String[] args) {
Collection<String> coll=new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
     //使用迭代器对集合ArrayList中的元素进行取出
 
//调用集合的方法iterator()获取出Iterator接口的实现类的对象
Iterator<String> it= coll.iterator();
//接口实现类对象，调用方法hasNext()判断集合中是否有元素
// boolean b=it.hasNext();
// System.out.println(b);
// //接口的实现类对象，调用方法next()取出集合中的元素
// String s=it.next();
// System.out.println(s);
 
//迭代是反复内容，使用循环实现，循环的条件是集合中没有元素
while (it.hasNext()) {
String a = it.next();
System.out.println(a);
}
  }
}


 //获取字符串长度
String s=(String)it.next();
System.out.println(s.length());
 


在JDK1.5之后出现新的接口java.lang.Interable
作用就是实现增强的for循环
格式：
for(数据类型 变量名：数组或者集合){
sop(变量);
}


好处：代码少，方便对容器遍历
弊端：没有索引，不能操作容器里面的元素


泛型指明集合存储的数据类型
JDK1.5出现新的安全机制，保证程序的安全性
泛型：指明了集合中的数据类型<数据类型>


JAVA中的泛型是伪泛型，编译后的class文件没有泛型


实现类在实现接口的同时，也指定了数据类型
public class XXX implements List<String>


泛型通配符*
public class GenericDemo02 {
   public static void main(String[] args) {
ArrayList<String> array=new ArrayList<String>();
 
HashSet<Integer> set=new HashSet<Integer>();
 
array.add("123");
array.add("456");
 
set.add(678);
set.add(890);
 
function(set);
function(array);
}
   /*
    * 定义方法，可以同时迭代2个集合
    * 参数:同时满足
    */
   public static void function(Collection<?> coll){
  Iterator<?> it=coll.iterator();
  while (it.hasNext()) {
 System.out.println(it.next());
}
   }
}


泛型的限定，限定的是父类
？ extends 父类，限制的是父类，上限限定
?  super 类  ，限制的是子类，下限限定


List接口派系，继承collection接口
List接口特点：有序，索引，可以重复元素
 下面的实现类：ArrayList
List接口中的抽象方法，有一部分方法和他的父接口Collection是一样的
拥有自己的特有方法，带有索引的功能


带有索引的操作注意数组越界的问题


ConcurrentModificationException 并发修改异常
在遍历的过程中，使用集合的方法修改了集合的长度，这是不允许的
public class ListDemo01 {
   public static void main(String[] args) {
 List<String> list=new ArrayList<String>();
 list.add("abc1");
 list.add("abc2");
 list.add("abc3");
 list.add("abc4");
 
 Iterator<String> it=list.iterator();
 while (it.hasNext()) {
String s = it.next();
//对获取出的元素s，进行判断，是不是有abc3这个元素
if (s.equals("abc3")) {
list.add("seryou");
}
System.out.println(s);
}


}
}


堆栈：先进先出 案例：压弹夹
队列：先进先出 案例：排队安检
链表：查找元素慢，通过连接的节点，一次向后查找指定元素
但是增删元素快，只需要修改连接下一个元素的地址即可


ArrayList元素增删慢，查找快，可用于遍历数据，作为常用集合


LinkedList提供了大量手尾操作的方法
LinkedList查询慢，增删快


addFirst(E) 添加到链表的开头
addLast(E) 添加到链表的结尾


vector集合数据存储的结构是数组结构


Set不包含重复元素的集合
set接口的实现类，HashSet
HashSet存储和取出顺序不同，是无序集合
public class HashSetDemo {
   public static void main(String[] args) {
Set<String> set=new HashSet<String>();
set.add("cn");
set.add("123");
set.add("abc");
set.add("345");
set.add("tgh");
 
Iterator<String> it=set.iterator();
while (it.hasNext()) {
String string = (String) it.next();
System.out.println(string);
}
}
}
不允许重复值


哈希表（链表数组结合体）
迭代性能受到桶的数量的影响
哈希值


public class HashSetDemo01 {
/*
 * 对象的哈希值就是普通的十进制整数
 */
public static void main(String[] args) {
Person p=new Person();
int i=p.hashCode();
System.out.println(i);
}
}


HashSet集合的自身特点：
  底层数据结构，哈希表
  存储，取出都比较快
  线程不安全，运行速度快
  
LinkedHashSet自身特性，具有顺序，存储和取出的顺序相同
线程不安全的集合，运行速度快


ArrayList里面的contains方法用来判断元素是否重复


Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值
Map键值对
Map<K,V>


Map接口中的常用方法，键值对用=分开
put放入集合，get从集合中取出


public class MapDemo {
   public static void main(String[] args) {
 function();
 function_1();
 function_2();
}
   /*
    * 移除集合中的键值对，返回被移除之前的值
    */
   private static void function_2() {
  Map<Integer, String> map=new HashMap<Integer,String>();
       map.put(1, "A");
       map.put(2, "B");
       map.put(3, "C");
       System.out.println(map);
       
       map.remove(3);
       System.out.println(map);
}
/*
    * 通过键对象，获取值对象
    */
   private static void function_1() {
       Map<Integer, String> map=new HashMap<Integer,String>();
       map.put(1, "A");
       map.put(2, "B");
       map.put(3, "C");
       System.out.println(map);
       
       String value=map.get(3);
       System.out.println(value);
  
}
/*
    * 将键值对存储到集合中
    */
   public static void function(){
  Map<String, Integer> map=new HashMap<String, Integer>();
  map.put("a", 1);
  map.put("b", 2);
  map.put("c", 3);
  System.out.println(map);
   }
}


Map的遍历
利用键获取值，Map接口中定义方法keySet，所有的键，存储到Set集合
public class MapDemo01 {
   public static void main(String[] args) {
  Map<String, Integer> map=new HashMap<String, Integer>();
  map.put("a", 11);
  map.put("b", 12);
  map.put("c", 13);
  map.put("d", 14);
  
  Set<String> set=map.keySet();
  System.out.println(set.getClass());
  Iterator<String> it=set.iterator();
  while (it.hasNext()) {
String key = it.next();
Integer value=map.get(key);
System.out.println(key+"....."+value);

}
}
}


Entry是一个嵌套接口，将键值对的对应关系封装成对象
public class MapDemo02 {
     public static void main(String[] args) {
Map<Integer, String> map=new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "qwe");
//调用map集合方法entryset()将集合中的映射关系对象，存储到Set集合
Set<Map.Entry<Integer, String>> set=map.entrySet();
//迭代set集合
Iterator<Map.Entry<Integer, String>> it=set.iterator();
while (it.hasNext()) {
//获取出的set集合的元素，是映射关系对象
//it.next获取的是什么对象也是Map.entry对象
Map.Entry<Integer,String> entry = it.next();
//通过映射关系对象方法getkey，getvalue获取键值对
Integer key=entry.getKey();
String value=entry.getValue();
System.out.println(key+"...."+value);

}
}
}


增强for不能遍历Map


/*
 * 使用HashMap集合，存储自定义对象
 * 自定义对象可以作为键，值
 */
public class HashMapDemo {
   public static void main(String[] args) {
  function();
}
   public static void function(){
  HashMap<String, Person> map=new HashMap<String, Person>();
  map.put("北京", new Person("A", 20));
  map.put("上海", new Person("B", 22));
  map.put("广州", new Person("C", 23));
  
  for (String key : map.keySet()) {
Person value=map.get(key);
System.out.println(key+"..."+value);
}
  System.out.println("==========================");
  for (Map.Entry<String, Person> entry:map.entrySet()) {
  String key=entry.getKey();
  Person value=entry.getValue();
  System.out.println(key+"...."+value);
}
   }
}


静态导入
减少开发的代码量
导入包的时候才能使用


public class VarArgumentsDemo {
public static void main(String[] args) {
//调用一个带有可变参数的方法，传递参数，可以任意
int sum=getSum(5,85,69,45,12,25);
System.out.println(sum);
}
/*
* 可变参数的注意事项
* 1.一个方法中可变参只能有一个
* 2.可变参数必须卸载参数列表的最后一位
* Object...o
*/

  /*
   * 定义方法，计算整数和
   * 前提：方法参数数据类型确定，参数的个数任意
   * 可变参数语法：数据类型。。。变量名
   * 可变参数，本质就是一个数组
   */
public static int getSum(int...a){
int sum=0;
for (int i : a) {
sum+=i;
}
return sum;
}
}


Collections.sort(list); 排序
Collections.shuffle(list); 随机