Java中的集合

一、集合框架
1、在之前的学习中，我们通常创建一个数组来存储对象，但是这个数组一旦创建，它的大小就固定了。但在很多情况下，我们并不知道存储对象的个数，这时候数组就不在适用。

2、Java实用类库提供了一套相当完整的集合类来解决这个问题，使得程序可以在任意时刻和任意位置创建任意数量的对象。集合类主要包括List链表、Set集合和Map映射等基本类型。

在接下来的叙述中，我们重点介绍的是实现List接口的ArrayList类

二、ArrayList类
1、ArrayList类，可以用来存储不限定个数的对象。

2、为了演示ArrayList类的基本操作，我们首先定义一个Cat类，作为链表中元素的类型。

class Cat{
	private String name;
	
	public String getName(){
		   return name;
	}
	
	public void setName(String name)	{
		   this.name=name;
	}
	
}

3、接着，我们再给出链表和元素的定义。

import java.util.ArrayList;
       ArrayList<Cat> cats=new ArrayList<Cat>();

       Cat tomcat=new Cat();
       tomcat.setName("Tom");

       Cat jackcat=new Cat();
       jackcat.setName("Jack");

       Cat johncat=new Cat();
       johncat.setName("John");

       Cat anncat=new Cat();
       anncat.setName("Ann");

4、下面将在此链表的基础上，演示链表和元素的基本操作。

（1）元素操作

       // 添加和删除元素
       cats.add(tomcat);    // tom(0)
       cats.add(jackcat);   // jack(1)-tom(0)
       cats.add(johncat);   // john(2)-jack(1)-tom(0)
       cats.add(2,anncat);  // 将下面的元素添加到第2个位置
                            // john(3)- anncat(2)-jack(1)-tom(0)
       cats.remove(jackcat);         // 删除元素
                            // john(2)- anncat(1)-tom(0)

       // 设置和获取元素
       cats.set(0,jackcat); // john(2)- anncat(1)-jack(0)

       System.out.println(cats.get(0).getName());

       // 判断元素和元素位置
       System.out.println(cats.contains(jackcat));
       System.out.println(cats.indexOf(jackcat));

（2）链表操作

       // 清除元素
       cats.clear();

       // 判断链表是否为空
       System.out.println(cats.isEmpty());

       // 将ArrayList转换为数组
       Cat[] c = cats.toArray(new Cat[0]);
       System.out.println(c[0].getName());

       // 将ArrayList转换为数组2
	   Cat[] array =new Cat[cats.size()];
	   cats.toArray(array);

	   for (int i=0;i<array.length;i++) {
		  System.out.println(array[i].getName());
	   }

（3）遍历操作

       // 通过索引值访问，可顺序遍历，也可随机访问。
       for (int i=0;i<cats.size();i++) {
	     System.out.println(cats.get(i).getName());
       }

       // 通过迭代器访问，实现顺序遍历。
       Iterator it = cats.iterator();
       while(it.hasNext()) {
          Cat cat = (Cat)it.next();
          System.out.println(cat.getName());
       }

       // 通过ForEach循环访问，实现顺序遍历。
       for (Cat cat:cats){
	      System.out.println(cat.getName());
       }

（4）输出结果

三、有关ArrayList类的几点说明
1、当创建ArrayList 后， 它的大小为 0。如果元索不在数组列表中，就不能使用get(index)和 set(index.element)方法。

2、由于 ArrayList 位于java.util 包中，所以在第一行导入该包

import java.util.ArrayList;

3、创建一个存储整数的列表时，下列做法是错误的

ArrayList<int> cityList=new ArrayList<>();

因为存储在 ArrayList 中的元素必须是一种对象。 不能使用诸如int的基本数据类型来代替一个泛型类型。然而， 你可以创建一个存储Integer对象的ArrayList, 如下所示：

ArrayList<Integer> cityList=new ArrayList<>();

4、数组和ArrayList之间的异同


5、关于列表的一些有用方法
（1）从数组创建一个数组列表

String[] array= {"red","green","blue"};
ArrayList<String> List=new ArrayList<>(Arrays.asList(array));

ArrayList类中的静态方法asList返回一个列表，该列表传递给ArrayList的构造方法用于创建一个ArrayList。

（2）从数组列表创建一个数组对象

String[] array= new String[List.size()];
List.toArray(array);

调用**List.toArray(array)**将List中的内容复制到array中。

（3）对列表中的元素进行排序
前提是列表中的元素可比较的，如整数、双精度浮点数或者字符串。

Integer[] array= {5,8,3,7,6,9};
ArrayList<Integer> List=new ArrayList<>(Arrays.asList(array));
java.util.Collections.sort(List);
System.out.println(List);

使用java.util.Collections类中的静态方法sort来对元素进行排序

（4）列表中的最大值、最小值

Integer[] array= {5,8,3,7,6,9};
ArrayList<Integer> List=new ArrayList<>(Arrays.asList(array));
System.out.println(java.util.Collections.max(List));
System.out.println(java.util.Collections.min(List));

使用java.util.Collections类中的静态方法max和min来返回列表中的最大元素和最小元素

（5）随机打乱列表的元素

Integer[] array= {3,5,6,7,8,9};
ArrayList<Integer> List=new ArrayList<>(Arrays.asList(array));
java.util.Collections.shuffle(List);
System.out.println(List);

使用java.util.Collections类中的静态方法shuffle来随机打乱列表的元素。

本文地址：https://blog.csdn.net/weixin_51004880/article/details/112093390