Java带你去看流浪世界！（十五——Ⅰ）

集合框架

集合的最简单的说法就是在朴素集合论（最原始的集合论）中的定义，即集合是“确定的一堆东西”，集合里的“东西”则称为元素。现代的集合一般被定义为：由一个或多个确定的元素所构成的整体

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。

在Java程序中如何临时存储数据：

**变量**

	**数组**：1.长度不能改变，2.数据类型单一

	String[] dishMsg = {xxx,xxx,xxx};

	String[] names = {xxx};

	int[] times = {10};

**类和对象（实体）**

	**对象数组**：它在一定程度上解决了数据类型单一的问题

	Order[] orders = {new Order(xxx),new Order(xxxx)};

	Order[] orders = new Order(xxx,xxx);

1.了解Java集合框架体系结构

1.为了解决数组长度不可变问题，学习集合框架！

2.为了解决更加复杂的数据存储问题。

实现可变数组

1.定义普通数组，长度随便指定一个

2.当有数据需要插入时，判断当前长度是否足够存储数据，如果不够创建新的数组。

	Arrays.copyOf（arr，length）；

3.将新数组返回

封装：功能聚合，封装成统一的API。

			Collection（收集） 顶级接口-<u>无序数据不唯一（可以重复）</u>

List接口-<u>数据不唯一（可重复）有序</u>				Set接口-<u>无序  数据唯一</u>	

ArrayList（实现类） LinkedList（实现类） HashSet（实现类） TreeSet（实现类）

工具类：

Collections

Arrays

2.会使用ArrayList存取数据

ArrayList<存储的数据的类型> 集合名 = new ArrayList<存储的数据的类型>();

1.boolean add(Object object); 存储元素

2.void add(int index,Object object); 向列表中的指定索引添加元素

3.int size(); 获取列表的长度/元素个数

4.Object get(int index); 根据索引获取对应的元素

5.boolean contains(Object obj);判断是否包含某个元素

6.boolean remove(Object obj);删除指定的元素

7.Object remove(int index);根据索引删除元素，且返回被删除的元素值

来自于ArrayList的父级接口

toArray()转换为数组

clear()清除所有的元素

isEmpty()判断是否为空集合/list.size() == 0;

iterator()迭代器

了解：Collections.shuffle(list);工具类的方法，可以用来随机打乱集合内的数据

了解：List Arrays.asList(T…t); 可以创建集合并且赋值

…

public class News{
    
    private int id;
    private String title;
    private String author;
    //提供getter和setter构造方法
    //提供有参和无参构造
}
public static void main(String[] args){
    //创建集合对象 List（有序 不唯一）-->ArrayList(可变数组)
    //<>泛型 规范需要添加
    //News[] news = new News[x];
    List<News> list = new ArrayList<News>();
    //存储数据
    //news[0] = xxx;  news [1] = xxx;
    News news1 = new News(1,"巴黎圣母院失火！","谁放的火");
    News news2 = new News(2,"巴黎圣母院失火！","谁放的火");
    News news3 = new News(3,"巴黎圣母院失火！","谁放的火");
    News news4 = new News(4,"巴黎圣母院失火！","谁放的火");
    News news5 = new News(5,"巴黎圣母院失火！","谁放的火");
    //boolean add = list.add(news1)
    list.add(news1);
    list.add(news2);
    list.add(news3);
    list.add(news4);
    //向指定的索引位置添加数据，原有数据一次后移
    list.add(0,news5);
    //获得新闻总数
    //news.length()
    int size = list.size();
    System.out.println("新闻的总数：" + size);
    //遍历集合
    //遍历数组，因为数组有索引，所以采用遍历索引，遍历数组
    for(int i = 0;i < list.size();i++){
        //集合根据索引获取数据
        News news = list.get(i);
        System.out.println(news.getTitle() + " ");
    }
    //查找是否包含其某个新闻内容
    System.out.println("查找是否有关于巴黎圣母院的相关新闻：" + list.contains(news5));
    //删除新闻
    list.remove(news5);
    //删除指定索引的数据，并且返回被删除的数据
    list.remove(0);
    System.out.println("查找是否有关于巴黎圣母院的相关新闻：" + list.contains(news5));
    
}

ArrayList的指引方法名和说明结束。

//ArrayList<Integer> arrayList = new ArrayList<>();

//可变参数
//List<T> asList(T...a);
List<String> list = Arrays.aslist("xxx","xxx","xxx");
List<Integer> list1 = Arrays.aslist(1,2,3,4,5);
/*
method1("xxx");
public static void method1(String xx){
    
}
*/
method2();
method2("xxx");
method2("xxx","xxx");

//可变参数，可以指定参数为0个或者多个，本质上是数组
public static void method2(String... s){
    for(int i = 0;i < s.length;i++){
        s[i];
    }
}

集合泛型的特点：它是用来约束/声明集合元素的数据类型的。

1.泛型必须是引用数据类型，如果是存储基本数据类型值，则必须将其转为引用数据类型（包装类型）

//在集合的泛型位置，要填写的数据类型是引用数据类型
//int byte --> 引用数据类型（包装类型）
/*byte-> Byte
short ->Short
int->Integer
long->Long
float->Float
double->Double
char->Character
boolean   Boolean
*/

3.会使用LinkedList存取数据

底层的链表

LinkedList linkedList = new LinkedList<>();

List接口中的API它也拥有

1.addFirst(Object obj);将元素添加到第一个

2.addLast(Object obj);将元素添加到最后一个

3.Object getFirst();获取第一个

4.Object getLast();获取最后一个

5.Object removeFirst();删除第一个

6.Object removeLast();删除最后一个

public static void main(String[] args){
    //创建集合对象 List（有序 不唯一）-->ArrayList(可变数组)
    //<>泛型 规范需要添加
    //News[] news = new News[x];
    LinkedList<News> list = newLinkedList<News>();
    //存储数据
    //news[0] = xxx;  news [1] = xxx;
    News news1 = new News(1,"巴黎圣母院失火！","谁放的火");
    News news2 = new News(2,"巴黎圣母院失火！","谁放的火");
    News news3 = new News(3,"巴黎圣母院失火！","谁放的火");
    News news4 = new News(4,"巴黎圣母院失火！","谁放的火");
    News news5 = new News(5,"巴黎圣母院失火！","谁放的火");
    News news6 = new News(6,"巴黎圣母院失火！","谁放的火");
    News news7 = new News(7,"巴黎圣母院失火！","谁放的火");
    //boolean add = list.add(news1)
    list.add(news1);
    list.add(news2);
    list.add(news3);
    list.add(news4);
    //向指定的索引位置添加数据，原有数据一次后移
    list.add(0,news5);
    //获得新闻总数
    //news.length()
    int size = list.size();
    System.out.println("新闻的总数：" + size);
    //遍历集合
    //遍历数组，因为数组有索引，所以采用遍历索引，遍历数组
    for(int i = 0;i < list.size();i++){
        //集合根据索引获取数据
        News news = list.get(i);
        System.out.println(news.getTitle() + " ");
    }
    //查找是否包含其某个新闻内容
    System.out.println("查找是否有关于巴黎圣母院的相关新闻：" + list.contains(news5));
    //删除新闻
    list.remove(news5);
    //删除指定索引的数据，并且返回被删除的数据
    list.remove(0);
    System.out.println("查找是否有关于巴黎圣母院的相关新闻：" + list.contains(news5));
    
    list.addFirst(news6);//添加到第一个
    list.addLast(news7);//添加到最后一个
    
    list.removeFirst(); //删除第一个
    list.removeLast();//删除最后一个

4.了解ArrayList和LinkedList的区别？（面试题）

ArrayList：底层是数组结构，所以因为是数组，则拥有索引，在遍历火随机查找是比较快，但是有因为是数组，所以数组长度不可变，每一次增删都是要创建新的数组，比较慢。

LinkedList：底层是链表结构，链表结构每一个元素由两部分组成，数据域和指针域，它没有索引。多个元素之间，通过指针域指向连接。因为没有索引，所以查找比较慢，但是因为是链表所以在增删时，只需要切换指针指向即可（尤其首尾更快）。

在我们使用时，发现ArrayList和LinkedList好像都拥有索引，为什么呢？

他们的索引不同！

ArrayList的索引是固定的。

LinkedList的索引是根据元素位置计算出来，并非固定的。

5.掌握使用Set集合存取数据

无序且唯一

HashSet

1.其实它实现唯一是根基hashCode()和epuals()来做的比较。

public static void main(String[] args){
    //创建对象
    Set<Integer> set = new HashSet<Integer>();
    set.add(1);
    set.add(2);
    set.add(3);
    set.add(3);//它会根据hashCode()等值进行判断，自行进行判断是否重复，出现重复不累加输出
    //无序(它存储的位置是根据hashCode()计算出来<有一定规律>)
    System.out.println(set);
    
    HashSet<News> newsSet = new HashSet<News>();
    
    News news1 = new News(1,"巴黎圣母院失火！","谁放的火");
    News news2 = new News(2,"巴黎圣母院失火！","谁放的火");
    News news3 = new News(3,"巴黎圣母院失火！","谁放的火");
    News news4 = new News(4,"巴黎圣母院失火！","谁放的火");
    News news5 = new News(5,"巴黎圣母院失火！","谁放的火");
    
    newsSet.add(news1);
    newsSet.add(news2);
    newsSet.add(news3);
    for(Object obj : news){
        //需要强转，父类不能调用子类对象，
        News news = (News)Obj;
        //String重epuals所以自动进行判断String类型是判断他的内容。
        System.out.println(news.getTitle() + " ");
  
}

迭代器Iterator

Iterator<String> iterator = list.iterator();
//interator.hasNext()//判断是否有下一个元素
//interator.Next()//获取下一个元素
while(interator.hasNext()){
    String value = iterator.next();
    System.out.println(value);
}
Iterator<String> setIterator = set.iterator();
while(setIterator.hasNext()){
    String str = setIterator.next();
    System.out.println(str);
}