Day12

Day12 枚举和容器

一、enum 枚举

可以用来表示一种事物的所有可能

注意:

•  1.枚举都隐示的继承自java.lang.Enum
  

•  2.枚举也是一种比较特殊的类,枚举中得饿所有成员都是当前枚举类的一个实例(对象),成员默认public static final修饰
  

•  3.不允许外部实例化,只能使用枚举类中提供的成员
  

格式：

​ //1.成员

​ //2.属性

​ //3.无参构造器

​ //4.有参构造器

​ //5.行为功能

举例：

//枚举类
enum Week{
   //枚举的成员,当前 枚举类的实例(对象),这些由我们程序员指定,只能有这些,不能外部new实例化-->所以称为当前这个类的所有可能
   Mon,Tue,Sun("第七天",10);  //Sun("第七天") ->Sun对象名  (参数)-->构造器的实参
   
   //属性
   private String name;
   private int num;
  
   private Week() { // TODO Auto-generated constructor stub
   }
  
   private Week(String name) {
      this.name = name; 
   } 
  
   private Week(String name, int num) {
      this.name = name;
      this.num = num;
   }

   public String getName() {
        return name; 
   }

}

public class EnumDemo01 {
   public static void main(String[] args) {
      //new Student().weekday = WeekDay.Mon;
      
      //枚举类型实例的获取
      Week w = Week.Sun;
      //成员名字
      System.out.println(w.name());
      //索引
      System.out.println(w.ordinal());
      
      //w.setName("周日");
      System.out.println(w.getName()); 
      w.test();
       
      
      //判断枚举类型的
      switch(w) {
      case Mon:
         System.out.println("周一");
         break;
      case Sun:
         System.out.println("周天");
         break;
      }
   }
}

二、容器

1.定义

• 容器:
• 容器的长度可以根据数据的多少自动增删
• 是引用数据类型
• 容器中可以存储任意类型的数据

2.数组的特性 --> 与容器区别

容器类似于数组，但有区别

• 数组和容器: 都可以存储多个数据
• 数组的特点:
• 有序,索引
• 数据类型一致
• 长度一旦确定不可改变

3.代码举例、格式

Collection接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZxjONJ6P-1594236901240)(D:/study/Doc/Note/image-20200708225232996.png)]

import java.util.ArrayList;
import java.util.List;

public class ContainerDemo01 {
    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(456);
        list.add(new Person());
        System.out.println(list.size());		//打印容器成员个数

        list.remove(0);		//根据索引删除成员
        System.out.println(list);			//打印容器所有成员
        System.out.println(list.size());

        System.out.println(list.get(0));		//根据索引，打印指定成员
        System.out.println(list);

        System.out.println(list.get(-1));		//超出范围，报错
        System.out.println(list);
        
       	//修改

    }
}

class Person{}

4.特性

• 容器中只能存放引用数据类型的数据
• Collection:
• 一些实现类可重复有序List 一些不可冲无序Set

*定义自定义的引用数据类型的数据,存放在容器中ArrayList

5.迭代器 -------?

• 遍历方式:

• 1.增强for foreach

• 2.迭代器

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

List 接口

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hWEzSkmi-1594236901243)(D:/study/Doc/Note/image-20200708224945007.png)]

泛型

//准备一个List容器,存放我喜欢的电影名字
//泛型: 规定使用数据的类型-->好处增强程序的可读性和稳定性。
//只能存放字符串类型
List<String> list = new ArrayList<String>();
list.add("记忆碎片 ");
list.add("无间道");
list.add("星际穿越");
list.add("后来的我们");
System.out.println(list);

List常用

//add增添 (在容器指定索引位置增添，原位置元素及后面的统一后移一个索引位置)
list.add(3, "时间规划局");
list.add(5, "无间道");
System.out.println(list);

//get 获取
System.out.println(list.get(2));

//indexOf 根据元素查找对应索引，默认从前往后
System.out.println(list.indexOf("无间道"));
System.out.println(list.lastIndexOf("无间道"));

System.out.println("------");
//remove 移除,有重复的默认第一个，索引、元素名都可
System.out.println(list.remove(4));
System.out.println(list);

//替换
System.out.println("------");
System.out.println(list.set(4,"头号玩家")); //此行只会打印被替换的元素名，容器里的已被替换，但不会打印
System.out.println(list);

ListIterator 列表迭代器

        //ListIterator 列表迭代器
        ListIterator it2 = list.listIterator();
        while (it2.hasNext()){
            if("灭霸".equals(it2.next())){
                it2.add("11111");
            }
//            System.out.println(list);		//遍历，有一个元素，就打印一次

List 接口的实现

• AarryList :
• 底层实现: 可变数组实现的,内部 通过数组拷贝实现根据内容可变长
• 优点 : 根据索引查询效率高

•     缺点 :错增加删除时效率低,因为要通过数组拷贝实现
  

• 应用场景: 存储耽搁数据,有序可以重复–>大量做查询,少量增删,推荐使用ArrayList
• 扩容: 在第一次添加数据时候初始容量10 , 通过Arrays.copyof方法进行动态扩容,每次扩容原容量的1.5倍 int newCapacity = oldCapacity + (oldCapacity >> 1);
• Vector:

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

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

• 与ArrayList不同点: 1)AarryList线程不安全 ,vector线程安全 2)扩容问题: ArrayList1.5倍增长 vector2倍增长 ArrayList更有利于节省内存
• LinkedList:
• 底层实现: 双向链表实现的
  *优点:增删效率高
• 缺点: 查询效率低
• 应用场景: 存储耽搁数据,有序可以重复–>如果做大量的增删,少量的查询,推荐使用LinkedList
• ArrayList()

          构造一个初始容量为 10 的空列表。 
ArrayList(Collection<? extends E> c) 
          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 
ArrayList(int initialCapacity) 
          构造一个具有指定初始容量的空列表。 

->如果做大量的增删,少量的查询,推荐使用LinkedList
*

• ArrayList()

          构造一个初始容量为 10 的空列表。 
ArrayList(Collection<? extends E> c) 
          构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 
ArrayList(int initialCapacity) 
          构造一个具有指定初始容量的空列表。