几分钟了解容器和枚举

1、枚举

枚举由enum关键字修饰，可以用来表示一种事物的所有可能

1、枚举都隐示的继承自java.long.Enum

2、枚举是一种比较特殊的类，枚举中的所有成员都是当前类的一个实例（对象）。成员默认Public static final修饰

3、枚举类不允许外部实例化，即不能new对象，只能使用枚举类的成员

enum Week{
	//枚举的成员,当前 枚举类的实例(对象),这些由我们程序员指定,只能有这些,不能外部new实例化-->所以称为当前这个类的所有可能
	MON,TUE,SUN("第七天",10);  //Sun("第七天") ->Sun对象名  (参数)-->构造器的实参

		//枚举类型实例的获取
		Week w = Week.Sun;
		//成员名字
		System.out.println(w.name());
		//索引
		System.out.println(w.ordinal());

2、容器

数组与容器的对比

数组是一种简单的线性序列，可以快速的访问数组元素，效率高。从效率和类型检查的角度讲，数组是最好的。但是数组的长度一旦确定就不能更改了，不够因此，不灵活：容量需要 事先定义好，不能随着需求的变化而扩容。显然不能满足我们的需求。所以我们需要一种灵活的，容量可以随时扩充的容器来装载我们的对象，即为容器类，或者叫集合框架。

数组的特点：1、有序、索引

​ 2、数组类型一致

​ 3、长度一旦确定不可改变

容器的特点：1、容器的长度可以根据数据的多少自动增删

​ 2、是引用是引用数据类型

​ 3、容器中可以存储任意类型的数据

public static void main(String[] args) {
		Person[] arr = {new Person(),new Person()} ;
		System.out.println(arr.length);
		
		//容器的使用  
		List list = new ArrayList();
		list.add("zhangsan");
		list.add(123);
		list.add(new Person());
		System.out.println(list.size());
		list.add(new Person());
		System.out.println(list.size());
		
		System.out.println(list);
		list.remove(0);
		System.out.println(list.size());
		System.out.println(list.get(-1));
		
	}

集合框架的简单体系是：

1、Collection 接口是一组允许重复的对象。

​ 1>Set 接口继承 Collection，无序不允许重复，使用自己内部的一个排列机制。

​ 1>>HashSet

​ 2>List 接口继承 Collection，有序允许重复，以元素安插的次序来放置元素， 不会重新排列。

​ 1>>LinkeList

​ 2>>ArrayList

2、Map 接口是一组成对的键值对象，即所持有的是 key-value pairs。Map 中不能有重 复的 key。拥有自己的内 部排列机制。

​ 1>HashMap

注意：容器中的元素类型都为引用类型，不能放置原生数据类型(使用装箱即可)，使用泛 型保留类型

Collection 接口

Collection 表示一组对象，它是集中，收集的意思，就是把一些数据收集起来，Collection 接口的两个子接口：

1、Set 中的数据没有顺序，不可重复

2、List 中的数据有顺序，可重复

容器中只能存放引用数据类型的数据
* Collection:
*  一些实现类可重复有序List   一些不可重复无序Set
*  
*定义自定义的引用数据类型的数据,存放在容器中ArrayList

 遍历方式:
*  1.增强for   foreach
*  2.迭代器

遍历   foreach
for(Object o: coll2) {
   System.out.println(o);
}

迭代器
  1.获取容器的迭代器
Iterator it = coll2.iterator();
  2.循环判断是否存在下一个元素
while(it.hasNext()) {
     3.获取
   System.out.println(it.next());
}

List接口

List 接口 有序可重复，新增了一些根据索引操作的方法

遍历方式:
  普通 for
  foreach
  迭代器 iterator

泛型:“<>” ，两个尖括号表示泛型，把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

装入集合的类型都被当作 Object 对待，从而失去自己的实际类型。

从集合中取出时往往需要转型，效率低，容易产生错误。z

规定使用数据的类型–>好处增强程序的可读性和稳定性。

**一个练习充分了解List接口。

List<String> list = new ArrayList<String>();

定义一个List容器,存放你喜欢的漫威人物,判断如果里面有灭霸,就添加一个惊奇队长!!!
 *  
 */
public class ListDemo02 {
   public static void main(String[] args) {
      List<String> list = new ArrayList();
      list.add("钢铁侠");
      list.add("寇尔森");
      list.add("灭霸");
      list.add("死侍");
      list.add("蚁人");
      
      //1. constains
//    if(list.contains("灭霸")) {
//       list.add("惊奇队长");
//    }
//    System.out.println(list);
      
      System.out.println(list);
      //2.for
//    for(int i =0;i<list.size();i++) {
//       if("灭霸".equals(list.get(i))) {
//          list.add("惊奇队长");
//       }
//    }
//    System.out.println(list);
      
      //2.foreach  -->java.util.ConcurrentModificationException
//    for(String s:list) {  //给泛型了才能使用String,否则使用Object
//       if("灭霸".equals(s)) {
//          list.add("惊奇队长");
//       }
//    }
//    System.out.println(list);
      
      
      //迭代器 iterator  ConcurrentModificationException
//    for(Iterator<String> it = list.iterator();it.hasNext();) {
//       if("灭霸".equals(it.next())) {
//          list.add("惊奇队长");
//       }
//    }
//    System.out.println(list);
      
      //ListIterator列表迭代器
      ListIterator it2 = list.listIterator();
      while(it2.hasNext()) {
         if("灭霸".equals(it2.next())) {
            it2.add("惊奇队长");
         }
      }
      System.out.println(list);
      
      //逆向遍历
      //boolean hasPrevious() 
      // E previous()  
   }
}

ArrayList、vector、LinkedList的区别

List接口的实现：

1、ArrayList:

底层实现: 可变数组实现的,内部 通过数组拷贝实现根据内容可变长

• 优点 : 根据索引查询效率高
• 缺点 :增加删除时效率低,因为要通过数组拷贝实现
• 应用场景: 存储单个数据,有序可以重复–>大量做查询,少量增删,推荐使用ArrayList
• 扩容: 在第一次添加数据时候初始容量10 , 通过Arrays.copyof方法进行动态扩容,每次扩容原容量的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);

2、vector

底层实现: 可变数组实现的,

• 扩容:: 在第一次添加数据时候初始容量10 , 每次扩容原容量的2倍

• 与ArrayList不同点:

  1>>AarryList线程不安全 ,vector线程安全

  2>>扩容问题: ArrayList1.5倍增长 vector2倍增长 ArrayList更有利于节省内存

3、LinkedList:

底层实现: 双向链表实现的
优点:增删效率高

​ 缺点: 查询效率低

​ 应用场景: 存储耽搁数据,有序可以重复–>如果做大量的增删,少量的查询,推荐使用LinkedList