java 集合

         Collection:集合   Array：数组
         集合和数组非常类似，都是存储数据的一个容器。
         区别：
         数组是定长，且只能存储相同类型的数据。
         集合是变长，不仅可以存储相同数据而且可以存储不同类型的数据的容器。
         Java中的集合可以看成JavaScript的数组。仅仅是概念一样，代码完全不一样。
   
         备注：和集合相关的类都需要导包。注意都是java.util下。
         
         
         

         Java中的集合分为两大类：
         A.单列集合（类似数组，只需要存值，通过下标访问值）
         B.双列集合（类似对象，不仅需要存值，还要存与之对应的属性名，通过属性名访问属性值）
         
         Collection就是所有单列集合的父接口
         所有单列集合都实现了该接口，所以：所有单列集合都拥有共同的方法。
         所以学会了一种单列集合，剩下的单列集合都能依葫芦画瓢。

         Collection又分为：
         List子接口（内部元素：有序且可以重复）
         
         Set子接口（内部元素：无序且无法重复）


         List接口下主要分为以下两个实现类：
         
         ArrayList 集合：采用数组结构，元素增删慢,查找快,由于日常开发中使用最多的功能就是查询,            所以 ArrayList 是最常用的集合之一
         。没有保证线程安全，但是效率高。
         
         Vector集合：    保证了线程安全，但是效率较低。除此和ArrayList都一样
         
         LinkedList 集合：采用链表结构。元素增删快,但是查找慢。

         线程安全：保证多个用户共同使用它也不会出错
         数组结构：元素增删慢,查找快
         链表结构：元素增删快,查找慢
         
         原因：
         数组结构是有序的，每个元素都有一个下标，查找的时候只需要根据下标查找即可，所以元素的查         找快，但是一旦发生了元素的增加或减少，
         会引发每个元素的下标发生变化，导致增删慢。
           
         链表结构是无序的，每个元素仅仅存储了本身的值，和引入下一个元素的地址。
         所以查询都是一个一个轮流查询，而不是像数组结构，直接根据下标查询。
         但是增删快，因为只需要对增删位置的元素进行修改即可，不会影响别的元素。



集合
         
单列集合(Collection)           双列集合(Map)
List(接口)               Set(接口)          HashMap(实现类)         
ArrayList  LinkedList Vector  HashSet  

常见的集合1: ArrayList:
复习： 特点1：采用了数组结构：查询快。增删慢    特点2：线程非安全所以效率快
特点3：有序且可以重复    特点4：父类是List  祖父类:Collection
      
      

      //如何创建一个ArrayList ：类似于多态：  左边放父类 右边放自类
      List  list = new ArrayList();
      
      
//    boolean add(Object o); //往集合尾部添加元素，一般不需要返回值  
      System.out.println(list.add("张三"));
      System.out.println(list.add("李四"));
      System.out.println(list.add("wangw"));
      System.out.println(list.add("jakc"));
//    void add(int index, Object o );//往集合指定位置添加元素
      list.add(2,"王五");
      System.out.println(list);
      
      
      //常见的方法：
//    int size();   //返回集合的长度
      System.out.println(list.size());
      
//    boolean isEmpty(); //判断集合的内部是否为null 注意：并不是判断集合为空 
      System.out.println(list.isEmpty());
      
//    boolean contains(Object o);  //判断集合内部是否存在该值
      System.out.println(list.contains("张三1"));
      

   boolean remove(Object o);//删除集合指定的元素值
      System.out.println(list.remove(0));//根据下标删除
      System.out.println(list.remove("jakc"));
      System.out.println(list);

 int indexOf(Object o);//返回指定元素首次出现的位置。-1表示不存在
  System.out.println(list.indexOf("王五123"));
      
      
  boolean equals(Object o);//判断两个集合是否   值和顺序都相等
  也重写了Object的equals方法

Object  get(index)  获取指定位置的元素
      System.out.println(list.get(2) + "~~");
      
      List l1 = new ArrayList();
      List l2 = new ArrayList();
      l1.add(123);
      l2.add(123);
      System.out.println(l1==l2);
      System.out.println(l1.equals(l2));
      

public class Test3 {
	public static void main(String[] args) {
		//复习： 特点1：单列集合 父类是List 祖父类Collction
		//特点2：数组结构   特点：有序可重复   线程安全效率低
		
//		List list = new Vector();
//		list.add(true);
//		list.add("nihao");
//		System.out.println(list);
		
		
		
		//案例：测试ArrayList和Vector 同时增加100000个元素的效率差
		
		
//		long l1 = System.currentTimeMillis();
//		List list = new ArrayList();
//		for(int i = 1; i<=1000000;i++) {
//			list.add(i);
//		}
//		System.out.println(list.size());
//		long l2 = System.currentTimeMillis();//16毫秒
//		System.out.println(l2-l1);
		
//		long l1 = System.currentTimeMillis();
//		List list = new Vector();
//		for(int i = 1; i<=1000000;i++) {
//			list.add(i);
//		} 
		
//		System.out.println(list.size());
//		long l2 = System.currentTimeMillis();//28毫秒
//		System.out.println(l2-l1);
//		
		
		
	}

public class Test4 {
	
	public static void main(String[] args) {
		//LinkList:特点： 父类都是List祖父类都是Coolection  有序 可重复
		//链表结构  增删快。查询慢
//		List list = new LinkedList();
		//常见的方法如上一样。
		
		
		
		//案例：测试ArrayList 和  LinkList 的效率
		
		List list1 = new ArrayList();
		List list2 = new LinkedList();
		for(int i = 1; i<=10000000;i++) {
			list1.add(i);
			list2.add(i);
		}
		
		long l1 = System.currentTimeMillis();
		int i = list1.indexOf(9999999);
		System.out.println(i);
		long l2 = System.currentTimeMillis();
		System.out.println(l2-l1);
		
		
		
		
		
	}
	
}

public class Test5 {
	public static void main(String[] args) {
		//Set集合接口： 特点：单列集合 父类依然是Collection
		//特点：无序无法重复。  该接口下有一个常见类：HashSet
		
		Set<Object>  set = new HashSet<Object>();
		
		set.add(true);
		set.add(123);
		set.add("你好");
		set.add(123);
		System.out.println(set);
		
		
		//如何遍历集合
		//如果List集合 普通for循环即可完成遍历
		
		//但是set集合  没有下标    增强for循环
//		for(Object o :set ) {
//			System.out.println(o);
//		}
//		
		
		Iterator<Object> it = set.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		
		//泛型的概念 ：就是每个集合后面跟着的 <E>   E表示这个集合应该存储什么类型的数据
		//集合：可以存放不同类型的。但是即使这样，你也要声明
		
		
	}
}

public class Test6 {
	public static void main(String[] args) {
		Set<Student> set = new HashSet<Student>();
		Student s1 = new Student(1, "jack1", 12);
		Student s2 = new Student(2, "jack2", 13);
		Student s3 = new Student(3, "jack3", 14);
		Student s4 = new Student(1, "jack1", 12);
		set.add(s1);
		set.add(s2);
		set.add(s3);
		set.add(s4);
		System.out.println(set);
		//无序：如果存放的实体类，会出现一个BUG  当某个实体类的属性完全一致，按理来说应该视为相同的值。但是set不会这么做。
		//解决办法：重写hashCode方法即可
		
	
		//hash：哈希  一种编码    每个对象都有一个独一无二的hash值  你就理解为键盘上的26个字母
//		Integer a = 123;
//		String b = "Nihao";
//		System.out.println(a.hashCode());
//		System.out.println(b.hashCode());
//		//存在的意义：  判断对象是否相等
		//一般来说判断对象是否相等都是通过==  但是==获取的内存地址 效率较低
		//所以hashCode效率较高、  hashCode相等，则进一步判断内存地址   如果hashCode都不能则内存地址肯定不等。
		
//		String a1 = new String("111");
//		String a2 = new String("111");
//		System.out.println(a1.hashCode());
//		System.out.println(a2.hashCode());
//		
//		Student s1 = new Student(1, "jack1", 12);
//		Student s2 = new Student(1, "jack1", 12);
//		System.out.println(s1.hashCode());
//		System.out.println(s2.hashCode());
		
	}
}	

public class Test7 {
	public static void main(String[] args) {
		//Map集合双列集合：   分别存储 键 和 值    键理解为属性名  value属性值
		//键绝对是独一无二的   一般来说键：String   值：Object  
		Map<String,Object> map = new HashMap<String,Object>();
		
		map.put("1001", "张三1");//添加元素
		map.put("1002", "张三2");
		map.put("1003", "张三3");
		System.out.println(map);
		
		System.out.println(map.get("1002"));//获取指定键 对应的值
		System.out.println(map.size());
		
		//如何遍历一个map集合
		//1.将其转成Set集合  
		Set<String> set = map.keySet();//将map集合中的键 全部转成set集合
		System.out.println(set);
		
		for(String s :set) {
			System.out.println(map.get(s));
		}
		
		
	}
}

public class Test8 {
	
	public static void main(String[] args) {
		//使用3种方式 遍历集合的效率
		
		List<Integer> list = new ArrayList<Integer>();
		
		for(int i = 1; i<=10000000;i++) {
			list.add(i);
		}
		
		System.out.println("准备完毕！！！！！！！！！！");
		
		
//		遍历集合的效率
		long l1 = System.currentTimeMillis();
		for(int i = 0 ;i<list.size();i++) {
			if(i==9999999) {
				System.out.println("111222");
			}
		}
		long l2 = System.currentTimeMillis();
		System.out.println("普通for循环的遍历效率为" +  (l2-l1) );//7
		
		
		long l3 = System.currentTimeMillis();
		for(Integer i : list) {
			if(i==9999999) {
				System.out.println("111222");
			}
		}
		long l4 = System.currentTimeMillis();
		System.out.println("增强for循环的遍历效率为" +  (l4-l3) );//35
		
		
		long l5 = System.currentTimeMillis();
		//任何集合都可以通过额外一个知识点： Iterator(迭代器)
		Iterator<Integer>  it = list.iterator();
		while(it.hasNext()) {//是否还有下一个元素
			if(it.next()==99999999) {
				
			}
		}
		long l6 = System.currentTimeMillis();
		System.out.println("迭代器循环的遍历效率为" +  (l6-l5) );//23
	}
	
}