ArrayList 类
ArrayList 类是一个可以动态修改的数组,与普通数组的区别就是它是没有固定大小的限制,我们可以添加或删除元素。ArrayList 继承了 AbstractList ,并实现了 List 接口。
ArrayList 类位于 java.util 包中,使用前需要引入它,语法格式如下:
import java.util.ArrayList; // 引入 ArrayList 类
ArrayList<E> objectName =new ArrayList<>(); // 初始化
-
添加元素到 ArrayList 可以使用 add( ) 方法:
-
访问 ArrayList 中的元素可以使用 get( ) 方法
-
如果要修改 ArrayList 中的元素可以使用 set( ) 方法
-
如果要删除 ArrayList 中的元素可以使用 remove( ) 方法
-
如果要计算 ArrayList 中的元素数量可以使用 size( ) 方法
-
迭代数组的方法可以使用最基础的for循环方法,也可以使用增强型循环的方法遍历数组
示例一:
import java.util.ArrayList;
public class RunoobTest {
public static void main(String[] args) {
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.remove(3); // 删除第四个元素
System.out.println(sites);
}
}
运行结果:
[Google, Runoob, Taobao]
LinkedList
链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的地址。
链表可分为单向链表和双向链表。
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。
Java LinkedList(链表) 类似于 ArrayList,是一种常用的数据容器。
与 ArrayList 相比,LinkedList 的增加和删除对操作效率更高,而查找和修改的操作效率较低。
以下情况使用 ArrayList :
- 频繁访问列表中的某一个元素。
- 只需要在列表末尾进行添加和删除元素操作。
以下情况使用 LinkedList :
- 你需要通过循环迭代来访问列表中的某些元素。
- 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。
使用 LinkedList的语法格式:
LinkedList 类位于 java.util 包中:
import java.util.LinkedList; // 引入 LinkedList 类
LinkedList<E> list = new LinkedList<E>(); // 普通创建方法
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表
- 使用 addFirst( ) 在头部添加元素
- 使用 addLast( ) 在尾部添加元素
- 使用 removeFirst( ) 移除头部元素
- 使用 removeLast( ) 移除尾部元素
- 使用 getLast( ) 获取尾部元素
示例:
// 引入 LinkedList 类
import java.util.LinkedList;
public class RunoobTest {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
// 使用 getLast() 获取尾部元素
System.out.println(sites.getLast());
}
}
运行结果:
Weibo
区别:
ArrayList 底层数据结构是数组,查询快,增删慢,线程不安全,效率高 ;
Vector 底层数据结构是数组,查询快,增删慢 线程安全 效率低;
LinkedList 底层数据结构是链表,查询慢,增删快 线程不安全 效率高;
泛型机制
**泛型机制:**就是把数据类型明确工作,推迟到创建对象或调用方法时,才去明确的一种机制。
泛型的好处:能够提高代码的扩展性,避免了向下转型,可以将问题提前到编译期。
泛型,只在编译期,有效在运行期,就擦除了。
泛型方法
你可以写一个泛型方法,该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。
定义泛型方法的规则:
- 所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的)。
- 每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
- 类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。
- 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。
示例一:
import java.util.ArrayList;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
ArrayList<String> aa = new ArrayList<>();
aa.add("abc");
aa.add("bbc");
aa.add("ccc");
String a = aa.get(0);
String b = aa.get(1);
String c = aa.get(2);
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
运行结果:
abc
bbc
ccc
Process finished with exit code 0
示例二:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
list.add(new Student("张国荣",23));
list.add(new Student("张国荣", 23));
list.add(new Student("张家辉", 23));
list.add(new Student("张震岳", 23));
list.add(new Student("张子豪", 23));
Iterator<Student> iterator = list.iterator();
while (iterator.hasNext()) {
Student student = iterator.next();
System.out.println(student);
}
}
}
运行结果:
Student{name='张国荣', age=23}
Student{name='张家辉', age=23}
Student{name='张震岳', age=23}
Student{name='张子豪', age=23}
Process finished with exit code 0
新式for循环
注意!!!
新式for循环在遍历集合时,底层用的还是迭代器,你在遍历途中,如果改变集合的长度,就会报并发修改异常。
ConcurrentModificationException 并发修改异常
ArrayList<Integer> integers = new ArrayList<>();
integers.add(200);
integers.add(200);
integers.add(200);
integers.add(200);
for (Integer integer : integers) {
if(integer.intValue()==200){
integers.add(300);
}
}
普通for循环
import java.util.ArrayList;
public class demo2 {
public static void main(String[] args) {
int[] arr={20,30,50};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
运行结果
20
30
50
增强循环
语法:
for(容器中的元素的数据类型 变量名:容器名)
import java.util.ArrayList;
public class demo2 {
public static void main(String[] args) {
int[] arr={20,30,50};
for(int a:arr){
System.out.println(a);
}
System.out.println("==============================");
ArrayList<Integer> integers = new ArrayList<>();
integers.add(200);
integers.add(200);
integers.add(200);
integers.add(200);
for(Integer num:integers){
System.out.println(num);
}
System.out.println("===============================");
}
}
运行结果:
20
30
50
==============================
200
200
200
200
===============================
Arrays.asList( )
注意:通过Arrays.asList() 这种方式的得到集合,不能再次改变集合的长度,也就是说,你不能增删元素。
UnsupportedOperationException
List<Integer> list = Arrays.asList(20, 20, 30, 50, 30);
System.out.println(list.get(0));
list.add(300);
list.remove(0);
//UnsupportedOperationException
Set 集合
元素唯一,不允许重复。
- HashSet
- LinkedHashSet
- TreeSet
**HashSet:**底层数据结构是哈希表(JDK1.7 数组+链表 JDK1.8 优化 数组+链表+红黑树) ,元素无序(存取元素的顺序不一致)且唯一(元素不允许重复)
HashSet集合保证元素的唯一性,是靠元素重新hashCode和**equals()**方法来保证的,如果元素不重写,则无法保证元素的 唯一性。
import java.util.HashSet;
public class demo3 {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("aaaa");
set.add("aaaa");
set.add("aaaa");
set.add("bbb");
set.add("ccc");
for (String s : set) {
System.out.println(s);
}
System.out.println("==========================");
HashSet<Integer> set2 = new HashSet<>();
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(200);
set2.add(100);
set2.add(300);
System.out.println(set2);
}
}
运行结果:
运算结果输出的时候回自动删除集合中重复的元素。
ccc
bbb
aaaa
==========================
[100, 200, 300]
Process finished with exit code 0
LinkedHashSet
LinkedHashSet 元素有序,且唯一,底层数据结构是链表+哈希表 链表保证元素有序,哈希表保证元素唯一。
示例一:
import java.util.LinkedHashSet;
public class demo5 {
public static void main(String[] args) {
LinkedHashSet<Integer> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(100);
linkedHashSet.add(100);
linkedHashSet.add(100);
linkedHashSet.add(200);
linkedHashSet.add(300);
linkedHashSet.add(400);
for (Integer integer : linkedHashSet) {
System.out.println(integer);
}
}
}
运行结果:
100
200
300
400
Process finished with exit code 0
TreeSet
TreeSet 底层数据结构是二叉树,元素唯一,且能对元素进行排序。
示例:
import java.util.LinkedHashSet;
import java.util.TreeSet;
public class demo5 {
public static void main(String[] args) {
//20, 18, 23, 22, 17, 24, 19, 18, 24
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(20);
treeSet.add(18);
treeSet.add(23);
treeSet.add(22);
treeSet.add(17);
treeSet.add(24);
treeSet.add(19);
treeSet.add(18);
treeSet.add(24);
for (Integer integer : treeSet) {
System.out.println(integer);
}
}
}
运行结果 :
17
18
19
20
22
23
24
Process finished with exit code 0
TreeSet 采用的两种排序方式,一种是 自然排序,一种是 比较器排序。
自然排序:采用空参构造,自然排序对元素有要求,
要求元素必须实现一个Comparable 接口 重写 compareTo(T o);
根据compareTo(T o);的返回值的 正 负 0 来决定元素在二叉树中放置左右的位置
构造方法
构造方法 | 说明 |
---|---|
TreeSet() | 构造一个空的树集合 |
TreeSet(Collection c) | 构造一个包含了集合 c 的树集合 |
TreeSet(Comparator< E> comparator) | 构造一个空的树集合,按照由 comp 指定的比较方法进行排序 |
TreeSet(SortedSet ss) | 构造一个包含了已排序集合 ss 的元素的树集合 |
提供的方法
类型 | 方法 | 说明 |
---|---|---|
E | first() | 返回集合中的最低元素,数据类型为 E |
E | last() | 返回集合中的最高元素,数据类型为 E |
E | pollFirst() | 返回并删除最低元素,数据类型为 E |
E | pollLast() | 返回并删除最高元素,数据类型为 E |
SortedSet<> | subSet(E fromElement, E toElement) | 返回一个新集合,包括 fromElement,不包括 toElement(即 [ ) ) |
SortedSet<> | tailSet(E fromElement) | 返回一个新集合,包括 fromElement |
SortedSet<> | headSet(E toElement) | 返回一个新集合,不包括 toElement |
自然排序
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;
public class test {
public static void main(String[] args) {
TreeSet ts = new TreeSet();
ts.add(3);
ts.add(4);
ts.add(2);
ts.add(1);
System.out.println(ts);
System.out.println(ts.size());
Iterator it = ts.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");//1 2 3 4
}
System.out.println();
System.out.print(ts.first() + " ");//1
System.out.print(ts.last() + " ");//4
System.out.print(ts.pollFirst() + " ");//1
System.out.print(ts.pollLast() + " ");//4
System.out.println();
SortedSet ss = ts.subSet(2, 3);
SortedSet ss2 = ts.headSet(3);
SortedSet ss3 = ts.tailSet(4);
it = ss.iterator();
while (it.hasNext()) {
System.out.print(it.next() + " ");//2
}
}
}
运行结果:
[1, 2, 3, 4]
4
1 2 3 4
1 4 1 4
2
比较器排序
import java.util.Comparator;
import java.util.TreeSet;
public class test {
public static void main(String[] args) {
//有参构造,传入比较器,使用比较器对元素进行排序
TreeSet<Integer> set = new TreeSet<Integer>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//元素前 - 元素后 : 升序
//元素后 - 元素前 : 降序
return o2 - o1;
}
});
set.add(20);
set.add(18);
set.add(23);
set.add(22);
set.add(17);
set.add(24);
set.add(19);
System.out.println(set);
}
}
运行结果:
[24, 23, 22, 20, 19, 18, 17]