java之数组&集合
文章目录
- 一、数组
- 数组概念
- Arrays类
- toString及sort
- asList
- 1.返回的 ArrayList 数组是一个定长列表，我们只能对其进行查看或者修改，但是不能进行添加或者删除操作
- 2.引用类型的数组和基本类型的数组区别
- 3.返回的列表ArrayList里面的元素都是引用，不是独立出来的对象
- 4.已知数组数据，如何快速获取一个可进行增删改查的列表List？
- 5.Arrays.asList() 方法使用场景
- Collection集合
- Collection集合的方法
- List接口
- List的子类-ArrayList集合
- List的子类-ArrayList集合
- Set接口
- Set的子类-HashSet集合
- Set的子类-LinkedHashSet
- Collections类
- Map集合
- Map的常用方法
- Map的常用子类
- HashMap
- LinkedHashMap
一、数组
数组概念
数组就是存储数据的容器，保证多个数据的数据类型要一致，长度固定
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Cat(){
}
@Override
public String toString() {
return "Cat{" +
"name='" + name + '\'' +
'}';
}
public static void main(String[] args) {
//数组定义方式1
int[] arr1 = new int[3];
arr1[0] = 10;
arr1[1] = 11;
arr1[2] = 12;
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
//数组定义方式2
int[] arr2 = new int[]{20, 21, 22};
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
//数组定义方式3
int[] arr3 = {30, 31, 32};
for (int i = 0; i < arr3.length; i++) {
System.out.println(arr3[i]);
}
//存放自定义类的元素
Cat[] c = new Cat[3];
c[0] = new Cat("xiaohua");
c[1] = new Cat("xiaohei");
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
}
}
}
执行结果：
10
11
12
20
21
22
30
31
32
Cat{name='xiaohua'}
Cat{name='xiaohei'}
null
Arrays类
java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来非常简单。
public static String toString(Object[] array)：返回数组元素的字符串形式。public static void sort(Object[] array)：对数组按升序进行排序。public static：返回由指定数组支持的固定大小列表。List asList(T... a)
toString及sort
import java.util.Arrays;
public class Hello {
public static void main(String[] args) {
int[] arr = {2,34,35,4,657};
// 数组内容转为字符串
String s = Arrays.toString(arr);
// 打印字符串,输出内容
System.out.println(s); // [2, 34, 35, 4, 657]
//排序
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [2, 4, 34, 35, 657]
}
}
asList
作用是返回由指定数组支持的固定大小列表。
注意：这个方法返回的 ArrayList 不是我们常用的集合类 java.util.ArrayList。这里的 ArrayList 是 Arrays 的一个内部类 java.util.Arrays.ArrayList。这个内部类有如下属性和方法：
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
1.返回的 ArrayList 数组是一个定长列表，我们只能对其进行查看或者修改，但是不能进行添加或者删除操作
import java.util.Arrays;
import java.util.List;
public class Hello {
public static void main(String[] args) {
String[] s= {"a","b","c"};
List<String> list1 = Arrays.asList(s);
System.out.println(list1.toString()); // [a, b, c]
list1.set(1, "d");
System.out.println(list1.toString()); //[a, d, c]
list1.add("g"); //添加元素报错，java.lang.UnsupportedOperationException
}
}
2.引用类型的数组和基本类型的数组区别
import java.util.Arrays;
import java.util.List;
public class Hello {
public static void main(String[] args) {
String[] str = {"a","b","c"};
List<String> listStr = Arrays.asList(str);
System.out.println(listStr.size());//3
int[] i = {1,2,3};
List<int[]> listI = Arrays.asList(i);//注意这里List参数为 int[] ，而不是 int
System.out.println(listI.size());//1
Integer[] in = {1,2,3};
List<Integer> listIn = Arrays.asList(in);//这里参数为int的包装类Integer，所以集合长度为3
System.out.println(listIn.size());//3
}
}
上面的结果第一个listStr.size()==3，而第二个 listI.size()==1。这是为什么呢？
我们看源码，在 Arrays.asList 中，方法声明为 List asList(T… a)。该方法接收一个可变参数，并且这个可变参数类型是作为泛型的参数。我们知道基本数据类型是不能作为泛型的参数的，但是数组是引用类型，所以数组是可以泛型化的，于是 int[] 作为了整个参数类型，而不是 int 作为参数类型。
3.返回的列表ArrayList里面的元素都是引用，不是独立出来的对象
String[] str = {"a","b","c"};
List<String> listStr = Arrays.asList(str);
//执行更新操作前
System.out.println(Arrays.toString(str));//[a, b, c]
listStr.set(0, "d");//将第一个元素a改为d
//执行更新操作后
System.out.println(Arrays.toString(str));//[d, b, c]
我们看修改集合的内容，原数组的内容也变化了，所以这里传入的是引用类型。
4.已知数组数据，如何快速获取一个可进行增删改查的列表List？
String[] str = {"a","b","c"};
List<String> listStr = new ArrayList<>(Arrays.asList(str));
listStr.add("d");
System.out.println(listStr.size());//4
System.out.println(listStr.toString());
5.Arrays.asList() 方法使用场景
Arrays工具类提供了一个方法asList, 使用该方法可以将一个变长参数或者数组转换成List 。但是，生成的List的长度是固定的；能够进行修改操作（比如，修改某个位置的元素）；不能执行影响长度的操作（如add、remove等操作），否则会抛出UnsupportedOperationException异常。
所以 Arrays.asList 比较适合那些已经有数组数据或者一些元素，而需要快速构建一个List，只用于读取操作，而不进行添加或删除操作的场景。
Collection集合
集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组既然都是容器，它们有什么区别呢？
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素，可以存储任意类型数据。集合存储的都是引用数据类型，如果想存储基本类型数据需要存储对应的包装类型。
Collection是单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是
java.util.List 和 java.util.Set 。其中， List 的特点是元素有序、元素可重复。 Set 的特点是元素不可重
复。 List 接口的主要实现类有 java.util.ArrayList 和 java.util.LinkedList ， Set 接口的主要实现类有
java.util.HashSet 和 java.util.LinkedHashSet 。
注意:这张图只是我们常用的集合有这些，不是说就只有这些集合。
Collection集合的方法
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。下面给出Collection中一些常用的方法
public boolean add(E e)： 把给定的对象添加到当前集合中 。public void clear():清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中
List接口
java.util.List 接口继承自 Collection 接口，是单列集合的一个重要分支，习惯性地会将实现了 List 接口的对象称为List集合。
List接口特点：
- 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、
22、33的顺序完成的）。 - 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
- 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操
作集合的特有方法：
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。public E get(int index):返回集合中指定位置的元素。public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素
List的子类-ArrayList集合
java.util.ArrayList 集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为
查询数据、遍历数据，所以 ArrayList 是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
List的子类-ArrayList集合
java.util.LinkedList 集合数据存储的结构是链表结构。方便元素添加、删除的集合。
Set接口
java.util.Set 接口和 java.util.List 接口一样，同样继承自 Collection 接口，它与 Collection 接口中的方
法基本一致，并没有对 Collection 接口进行功能上的扩充，只是比 Collection 接口更加严格了。与 List 接口不
同的是， Set 接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set的子类-HashSet集合
java.util.HashSet 是 Set 接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序
不能保证不一致)。 java.util.HashSet 底层的实现其实是一个 java.util.HashMap 支持，
HashSet 是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存储和查找性能。保证元素唯一性
的方式依赖于： hashCode 与 equals 方法。
Set的子类-LinkedHashSet
在HashSet下面有一个子类 java.util.LinkedHashSet ，它是链表和哈希表组合的一个数据存储结构。可以保证元素唯一且元素存放有序。
Collections类
java.utils.Collections 是集合工具类，用来对集合进行操作。
常用方法如下：
public static void shuffle(List list):打乱集合顺序。public static:将集合中元素按照默认规则排序。void sort(List list) public static:将集合中元素按照指定规则排序。void sort(List list，Comparator )
ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add(300);
list.add(200);
list.add(50);
System.out.println(list); //[100, 300, 200, 50]
//排序方法
Collections.sort(list);
System.out.println(list); //[50, 100, 200, 300]
Map集合
Collection 中的集合称为单列集合， Map 中的集合称为双列集合。
Collection 中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。Map 中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。Map 中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map的常用方法
Map接口中定义了很多方法，常用的如下：
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。public V get(Object key)根据指定的键，在Map集合中获取对应的值。public Set: 获取Map集合中所有的键，存储到Set集合中。keySet() public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)。public boolean containKey(Object key):判断该集合中是否有此键。
Map的常用子类
通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
HashMap
存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。【键保证不重复，但是元素存储无序】
LinkedHashMap
HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。【键保证不重复，且元素存储有序】
注意：Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。
HashMap<String, String> map = new HashMap<>();
map.put("dog", "狗");
map.put("cat", "猫");
map.put("bird", "鸟");
map.put("pig", "猪");
System.out.println(map); //{cat=猫, bird=鸟, dog=狗, pig=猪}
map.remove("cat");
System.out.println(map); //{bird=鸟, dog=狗, pig=猪}
//遍历map方式1：键找值方式
Set<String> keySet = map.keySet();
for (String key: keySet){
System.out.println(map.get(key));
}
/*输出
鸟
狗
猪
*/
//遍历map方式2：键值对方式
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> entry: entrySet){
System.out.println(entry.getKey()+": "+entry.getValue());
}
/*输出
bird: 鸟
dog: 狗
pig: 猪
*/
方式1：键找值方式
通过元素中的键，获取键所对应的值
方式2：键值对方式
键值对方式即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
Entry键值对对象:
Entry将key-value的一 一对应关系封装为对象即键值对对象。我们可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。
在Map集合中也提供了获取所有Entry对象的方法：
public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)。
获取了Entry对象 , 表示获取了一对键和值，那么同样Entry中 , 分别提供了获取键和获取值的方法：
public K getKey()：获取Entry对象中的键。public V getValue()：获取Entry对象中的值。
参考：
Java中List和ArrayList的区别(理解设计思想)
JDK1.8源码(四)——java.util.Arrays 类