JAVA~适合新手和复习~基础三（集合所有常用方法）

Java 集合框架

 

 

1 Set和List的区别
2 1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
3 
4 2. Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
5 
6 3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

ArrayList

 

 

 用法

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

示例

 1 import java.util.ArrayList;
 2 import java.util.Collections;  // 引入 Collections 类
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         ArrayList<String> sites = new ArrayList<String>();
 7         sites.add("Taobao");
 8         sites.add("Wiki");
 9         sites.add("Runoob");
10         sites.add("Weibo");
11         sites.add("Google");
12         Collections.sort(sites);  // 字母排序
13         for (String i : sites) {
14             System.out.println(i);
15         }
16     }
17 }
18 
19 
20 //结果
21 /*
22 *Google
23 *Runoob
24 *Taobao
25 *Weibo
26 *Wiki
27 */

ArrayList 方法

add方法

上面已经看过了

addAll() 方法

addAll() 方法将给定集合中的所有元素添加到 arraylist 中。

arraylist.addAll(原集合开始下标,插入的集合)
 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5        
 6         // 创建一个动态数组
 7         ArrayList<Integer> primeNumbers = new ArrayList<>();
 8         // 往动态数组里添加元素
 9         primeNumbers.add(3);
10         primeNumbers.add(5);
11         System.out.println("Prime Numbers: " + primeNumbers);
12 
13         // 创建另外的一个动态数组
14         ArrayList<Integer> numbers = new ArrayList<>();
15         numbers.add(1);
16         numbers.add(2);
17 
18         // 把 primeNumbers 的所有元素添加到 numbers 的动态数组中
19         numbers.addAll(primeNumbers);
20         System.out.println("Numbers: " + numbers);
21     }
22 }
23 //执行以上程序输出结果为：
24 
25 //Prime Numbers: [3, 5]
26 //Numbers: [1, 2, 3, 5]

clear() 方法与 removeAll() 方法

clear() 和removeAll() 方法用于删除动态数组中的所有元素。但是clear() 比 removeAll() 更快，更高效。

示例

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<Integer> oddNumbers = new ArrayList<>();

        // 往动态数组里面添加元素
        oddNumbers.add(1);
        oddNumbers.add(3);
        oddNumbers.add(5);
        System.out.println("奇数 ArrayList: " + oddNumbers);

        // 删除所有元素
        oddNumbers.removeAll(oddNumbers);
        System.out.println("使用 removeAll() 方法后: " + oddNumbers);
    }
}
执行以上程序输出结果为:

奇数 ArrayList: [1, 3, 5]
使用 removeAll() 方法后: []

clone() 方法

clone() 方法用于拷贝一份动态数组，属于浅拷贝

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 对 sites 进行拷贝
16         ArrayList<String> cloneSites = (ArrayList<String>)sites.clone();
17         System.out.println("拷贝 ArrayList: " + cloneSites);
18     }
19 }
20 执行以上程序输出结果为：
21 
22 网站列表: [Google, Runoob, Taobao]
23 拷贝 ArrayList: [Google, Runoob, Taobao]

contains() 方法

contains() 方法用于判断元素是否在动态数组中。

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 检查 Runoob 是否在这个数组中
16         System.out.print("Runoob 是否存在于 arraylist: ");
17         System.out.println(sites.contains("Runoob"));
18 
19         // 检查 Weibo 是否在这个数组中
20         System.out.print("Weibo 是否存在于 arraylist: ");
21         System.out.println(sites.contains("Weibo"));
22     }
23 }
24 执行以上程序输出结果为：
25 
26 Runoob 是否存在于 arraylist: true
27 Weibo 是否存在于 arraylist: false

get() 方法

get() 方法通过索引值获取动态数组中的元素。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 获取在索引值为1处的元素
        String element = sites.get(1);
        System.out.println("索引值为 1 的元素为: " + element);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]
索引值为 1 的元素为: Runoob

indexOf() 方法

indexOf() 方法返回动态数组中元素的索引值。

 1 获取动态数组元素的索引：
 2 
 3 实例
 4 import java.util.ArrayList;
 5 
 6 class Main {
 7     public static void main(String[] args){
 8 
 9         // 创建一个数组
10         ArrayList<String> sites = new ArrayList<>();
11 
12         sites.add("Google");
13         sites.add("Runoob");
14         sites.add("Taobao");
15         System.out.println("网站列表: " + sites);
16 
17 
18         // 查找位置索引值为 Runoob 的元素
19         int position1 = sites.indexOf("Runoob");
20         System.out.println("Runoob 的索引位置: " + position1);
21 
22         // 查找位置索引值为 Weibo 的元素
23         int position2 = sites.indexOf("Weibo");
24         System.out.println("Weibo 的索引位置: " + position2);
25     }
26 }
27 执行以上程序输出结果为：
28 
29 Runoob 的索引位置: 1
30 Weibo 的索引位置: -1

remove() 方法

remove() 方法用于删除动态数组里的单个元素。

 1 import java.util.ArrayList;
 2 
 3 class Main {
 4     public static void main(String[] args){
 5 
 6         // 创建一个数组
 7         ArrayList<String> sites = new ArrayList<>();
 8 
 9         sites.add("Google");
10         sites.add("Runoob");
11         sites.add("Taobao");
12         System.out.println("网站列表: " + sites);
13 
14 
15         // 删除元素 Taobao
16         boolean result = sites.remove("Taobao");
17         System.out.println("Taoabo 是否被删除? " + result);
18         System.out.println("使用 remove() 后: " + sites);
19 
20     }
21 }
22 执行以上程序输出结果为：
23 
24 网站列表: [Google, Runoob, Taobao]
25 Taoabo 是否被删除? true
26 使用 remove() 后: [Google, Runoob]

size() 方法

size() 方法用于返回动态数组中元素的数量。(和数组、字符窜的lenght类似)

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 得到数组中的元素个数
        int size = sites.size();
        System.out.println("动态数组长度: " + size);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]
动态数组长度: 3

 isEmpty() 

isEmpty() 方法用于判断动态数组是否为空。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        // 检查数组中是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("sites 是否为空? " + result);

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 检查该数组是否为空
        result = sites.isEmpty();  // false
        System.out.println("sites 是否为空? " + result);
    }
}
执行以上程序输出结果为：

sites 是否为空? true
网站列表: [Google, Runoob, Taobao]
sites 是否为空? false

subList() 方法

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Wiki");
        System.out.println("网站列表: " + sites);

        // 元素位置为1到3
        System.out.println("SubList: " + sites.subList(1, 3));
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao, Wiki]
SubList: [Runoob, Taobao]

 

 

set() 方法

 set() 方法用于替换动态数组中指定索引的元素。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

            // 索引 2 的元素被替换
        String element = sites.set(2, "Wiki");
        System.out.println("替换后: " + sites);
        System.out.println("被替换的元素: " + element);
    }
}
执行以上程序输出结果为：

替换后: [Google, Runoob, Wiki]
被替换的元素: Taobao

sort() 方法

sort() 方法根据指定的顺序对动态数组中的元素进行排序。

import java.util.ArrayList;
import java.util.Comparator;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        System.out.println("不排序: " + sites);

        // 元素进行升序排列
        sites.sort(Comparator.naturalOrder());
        System.out.println("排序后: " + sites);
    }
}
执行以上程序输出结果为：

网站列表: [Runoob, Google, Wiki, Taobao]
不排序: [Runoob, Google, Wiki, Taobao]
排序后: [Google, Runoob, Taobao, Wiki]

toArray() 方法

toArray() 方法将 Arraylist 对象转换为数组。

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 创建一个新的 String 类型的数组
        // 数组长度和 ArrayList 长度一样
        String[] arr = new String[sites.size()];

        // 将ArrayList对象转换成数组
        sites.toArray(arr);

        // 输出所有数组的元素
        System.out.print("Array: ");
        for(String item:arr) {
            System.out.print(item+", ");
        }
    }
}
执行以上程序输出结果为：

网站列表: [Runoob, Google, Wiki, Taobao]
Array: Runoob, Google, Wiki, Taobao,

toString() 方法

toString() 方法将 Arraylist 对象转换为字符串

import java.util.ArrayList;
import java.util.Comparator;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Runoob");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 将ArrayList转换为String类型
        String list = sites.toString();
        System.out.println("String: " + list);
    }
}
执行以上程序输出结果为：

  
网站列表: [Runoob, Google, Wiki, Taobao]
String: [Runoob, Google, Wiki, Taobao]

·ensureCapacity() 方法

ensureCapacity() 方法用于设置具有指定容量大小的动态数组。

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        // 设置 arraylist的容量大小
        sites.ensureCapacity(3);
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao]

lastIndexOf() 方法

lastIndexOf() 方法返回指定元素在动态数组中最后一次出现的位置

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Runoob");
        System.out.println("网站列表: " + sites);


        // 获取 Runoob 最后一次出现的位置
        int position1 = sites.lastIndexOf("Runoob");
        System.out.println("Runoob 最后出现的位置: " + position1);

        // Wiki 不在 arraylist 中
        // 返回 -1
        int position2 = sites.lastIndexOf("Wiki");
        System.out.println("Wiki 最后出现的位置: " + position2);
    }
}
执行以上程序输出结果为：

网站列表: [Google, Runoob, Taobao, Runoob]
Runoob 最后出现的位置: 3
Wiki 最后出现的位置: -1

·retainAll() 方法

retainAll() 方法用于保留 arraylist 中在指定集合中也存在的那些元素，也就是删除指定集合中不存在的那些元素

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Wiki");
        sites2.add("Runoob");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 保留元素
        sites.retainAll(sites2);
        System.out.println("保留的元素: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList 1: [Google, Runoob, Taobao]
ArrayList 2: [Wiki, Runoob, Google]
保留的元素: [Google, Runoob]

·containsAll() 方法

containsAll() 方法用于检测 arraylist 是否包含指定集合中的所有元素。。

import java.util.ArrayList;
class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Runoob");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 检查动态数组1是否包含动态数组2
        boolean result1 = sites.containsAll(sites2);
        System.out.println("ArrayList 1 包含了 ArrayList 2 的所有元素: " + result1);

        // 检查数组2是否包含数组1
        boolean result2 = sites2.containsAll(sites);
        System.out.println("ArrayList 2 包含了 ArrayList 1 的所有元素: " + result2);
    }
}
执行以上程序输出结果为：

ArrayList 1: [Google, Runoob, Taobao]
ArrayList 2: [Runoob, Google]
ArrayList 1 包含了 ArrayList 2 的所有元素: true
ArrayList 2 包含了 ArrayList 1 的所有元素: false

·trimToSize() 方法

trimToSize() 方法用于将动态数组中的容量调整为数组中的元素个数。

import java.util.ArrayList;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 调整容量为3
        sites.trimToSize();
        System.out.println("ArrayList 大小: " + sites.size());
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
ArrayList 大小: 3

·removeRange() 方法

removeRange() 方法用于删除指定索引之间存在的元素。

import java.util.*;

class Main extends ArrayList<String> {
    public static void main(String[] args) {
        // 创建一个动态数组
        Main sites = new Main();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Wiki");
        sites.add("Weibo");

        System.out.println("ArrayList : " + sites);

            // 删除从索引值1到3的元素
            sites.removeRange(1, 3);
            System.out.println("删除后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao, Wiki, Weibo]
删除后的 ArrayList: [Google, Wiki, Weibo]

replaceAll() 方法

replaceAll() 方法用于将给定的操作内容替换掉数组中每一个元素。

import java.util.*;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 将所有元素更改为大写
        sites.replaceAll(e -> e.toUpperCase());
        System.out.println("更新后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
更新后的 ArrayList: [GOOGLE, RUNOOB, TAOBAO]

removeIf() 方法

removeIf() 方法用于删除所有满足特定条件的数组元素。

import java.util.*;

class Main {
    public static void main(String[] args){

        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();
       
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 删除名称中带有 Tao 的元素
        sites.removeIf(e -> e.contains("Tao"));;
        System.out.println("删除后的 ArrayList: " + sites);
    }
}
执行以上程序输出结果为：

ArrayList : [Google, Runoob, Taobao]
删除后的 ArrayList: [Google, Runoob]

forEach() 方法

forEach() 方法用于遍历动态数组中每一个元素并执行特定操作。

import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<Integer> numbers = new ArrayList<>();

        // 往数组中添加元素
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("ArrayList: " + numbers);

        // 所有元素乘以 10
        System.out.print("更新 ArrayList: ");
       
        // 将 lambda 表达式传递给 forEach
        numbers.forEach((e) -> {
            e = e * 10;
            System.out.print(e + " ");
        });
    }
}
执行以上程序输出结果为：

ArrayList: [1, 2, 3, 4]
更新 ArrayList: 10 20 30 40

HashSet

 

 

 

1 HashSet 类位于 java.util 包中，使用前需要引入它，语法格式如下：
2 
3 import java.util.HashSet; // 引入 HashSet 类
4 以下实例我们创建一个 HashSet 对象 sites，用于保存字符串元素：
5 
6 HashSet<String> sites = new HashSet<String>();

添加元素

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites);
    }
}

判断元素是否存在

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  // 重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));
    }
}
执行以上代码，输出结果如下：

true

删除元素

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);
    }
}
执行以上代码，输出结果如下：

[Google, Runoob, Zhihu]

删除集合中所有元素可以使用 clear 方法：

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.clear();  
        System.out.println(sites);
    }
}
执行以上代码，输出结果如下：

[]

计算大小

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        System.out.println(sites.size());  
    }
}
执行以上代码，输出结果如下：

4

迭代 HashSet

//可以使用 for-each 来迭代 HashSet 中的元素。

//实例
// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        for (String i : sites) {
            System.out.println(i);
        }
    }
}
执行以上代码，输出结果如下：

Google
Runoob
Zhihu
Taobao

 

HashMap

 

 

 

HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashMap; // 引入 HashMap 类
以下实例我们创建一个 HashMap 对象 Sites， 整型（Integer）的 key 和字符串（String）类型的 value：

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

clear() 方法

clear() 方法用于删除指定 hashMap 中所有键/值对

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 从HashMap中删除所有映射
        sites.clear();
        System.out.println("使用 clear() 方法后: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
使用 clear() 方法后: {}

clone() 方法

clone() 方法用于复制一份 hashMap，属于浅拷贝。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 复制 sites
        HashMap<Integer, String> cloneSites = (HashMap<Integer, String>)sites.clone();
        System.out.println("Cloned HashMap: " + cloneSites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
Cloned HashMap: {1=Google, 2=Runoob, 3=Taobao}

isEmpty() 方法

isEmpty() 方法用于检查该 HashMap 是否为空。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        // 检查该 HashMap 是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("是否为空? " + result);

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        result = sites.isEmpty(); // false
        System.out.println("是否为空? " + result);
    }
}
执行以上程序输出结果为：

是否为空? true
HashMap: {1=Google, 2=Runoob, 3=Taobao}
是否为空? false

size() 方法

计算 hashMap 中键/值对的数量

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 获得该 HashMap 中键/值对映射的数量
        int size = sites.size();
        System.out.println("Size of HashMap: " + size);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
Size of HashMap: 3

put() 方法

put() 方法将指定的键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}

putAll() 方法

putAll() 方法将指定所有的键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);
        // 创建另一个 HashMap
        HashMap<Integer, String> sites2 = new HashMap<>();
        sites2.put(1, "Weibo");  // 已存在会被替换
        sites2.put(4, "Wiki");

        // 将所有的映射关系从 sites 添加到 sites2
        sites2.putAll(sites);
        System.out.println("sites2 HashMap: " + sites2);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
sites2 HashMap: {1=Google, 2=Runoob, 3=Taobao, 4=Wiki}

·putIfAbsent() 方法

putIfAbsent() 方法会先判断指定的键（key）是否存在，不存在则将键/值对插入到 HashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);
       

        // HashMap 不存在该key
        sites.putIfAbsent(4, "Weibo");

        // HashMap 中存在 Key
        sites.putIfAbsent(2, "Wiki");
        System.out.println("Updated Languages: " + sites);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Updated sites HashMap: {1=Google, 2=Runoob, 3=Taobao, 4=Weibo}

remove() 方法

remove() 方法用于删除hashMap 中指定键 key 对应的键值对(key-value)。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {

        HashMap<Integer, String> sites = new HashMap<>();
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("HashMap: " + sites);

        // 删除key为2的映射关系
        String siteName = sites.remove(2);  // return Runoob
        System.out.println("返回值: " + siteName);
        System.out.println("删除后的 HashMap: " + sites);
    }
}
执行以上程序输出结果为：

HashMap: {1=Google, 2=Runoob, 3=Taobao}
返回值: Runoob
删除后的 HashMap: {1=Google, 3=Taobao}

containsKey() 方法

containsKey() 方法检查 hashMap 中是否存在指定的 key

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        //检查 key 为 1 是否存在
        if(sites.containsKey(1)) {
            System.out.println("key 为 1 存在于 sites 中");
        }

    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 为 1 存在于 sites 中

containsValue() 方法

containsValue() 方法检查 hashMap 中是否存在指定的 value 。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<Integer, String> sites = new HashMap<>();
 7 
 8         // 往 HashMap 添加一些元素
 9         sites.put(1, "Google");
10         sites.put(2, "Runoob");
11         sites.put(3, "Taobao");
12         System.out.println("sites HashMap: " + sites);
13 
14         //检查映射中值value是否有Java
15         if(sites.containsValue("Runoob")) {
16             System.out.println("Runoob 存在于 sites 中");
17         }
18     }
19 }
20 执行以上程序输出结果为：
21 
22 sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
23 Runoob 存在于 sites 中

replace() 方法

replace() 方法替换 hashMap 中是指定的 key 对应的 value。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 替换key为2的映射
        String value = sites.replace(2, "Wiki");

        System.out.println("Replaced Value: " + value);
        System.out.println("Updated HashMap: " + sites);
    }
}
执行以上程序输出结果为：

Replaced Value: Runoob
Updated HashMap: {1=Google, 2=Wiki, 3=Taobao}

replaceAll() 方法

replaceAll() 方法将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 将所有的值更改为大写
        sites.replaceAll((key, value) -> value.toUpperCase());
        System.out.println("Updated HashMap: " + sites);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Updated HashMap: {1=GOOGLE, 2=RUNOOB, 3=TAOBAO}

get() 方法

get() 方法获取指定 key 对应对 value

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 得到 value
        String value = sites.get(1);
        System.out.println("key 1 对应的 value: " + value);
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
key 1 对应的 value: Google

getOrDefault() 方法

getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // key 的映射存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value1 = sites.getOrDefault(1, "Not Found");
        System.out.println("Value for key 1:  " + value1);

        // key 的映射不存在于 HashMap 中
        // Not Found - 如果 HashMap 中没有该 key，则返回默认值
        String value2 = sites.getOrDefault(4, "Not Found");
        System.out.println("Value for key 4: " + value2);
    }
}
执行以上程序输出结果为：

Value for key 1:  Google
Value for key 4: Not Found

forEach() 方法

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往 HashMap 中插入映射项
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("Normal Price: " + prices);

        System.out.print("Discounted Price: ");

        //通过 lambda 表达式使用 forEach()
        prices.forEach((key, value) -> {
            // value 价格减少百分之 10
            value = value - value * 10/100;
            System.out.print(key + "=" + value + " ");
        });
    }
}
执行以上程序输出结果为：

Normal Price: {Pant=150, Bag=300, Shoes=200}
Discounted Price: Pant=135 Bag=270 Shoes=180

entrySet() 方法

entrySet() 方法返回映射中包含的映射的 Set 视图。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 返回映射关系中 set view
        System.out.println("Set View: " + sites.entrySet());
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Set View: [1=Google, 2=Runoob, 3=Taobao]

 keySet() 方法

keySet() 方法返回映射中所有 key 组成的 Set 视图。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<Integer, String> sites = new HashMap<>();

        // 往 HashMap 添加一些元素
        sites.put(1, "Google");
        sites.put(2, "Runoob");
        sites.put(3, "Taobao");
        System.out.println("sites HashMap: " + sites);

        // 返回所有 key 组成的 set 集合视图
        System.out.println("Keys: " + sites.keySet());
    }
}
执行以上程序输出结果为：

sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
Keys: [1, 2, 3]

values() 方法

values() 方法返回映射中所有 value 组成的 Set 视图。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<Integer, String> sites = new HashMap<>();
 7 
 8         // 往 HashMap 添加一些元素
 9         sites.put(1, "Google");
10         sites.put(2, "Runoob");
11         sites.put(3, "Taobao");
12         System.out.println("sites HashMap: " + sites);
13 
14         // 返回所有value值组成的视图
15         System.out.println("Values: " + sites.values());
16 
17     }
18 }
19 执行以上程序输出结果为：
20 
21 sites HashMap: {1=Google, 2=Runoob, 3=Taobao}
22 Values: [Google, Runoob, Taobao]

·merge() 方法

merge() 方法会先判断指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
    //创建一个HashMap
    HashMap<String, Integer> prices = new HashMap<>();

    // 往 HashMap 插入映射
    prices.put("Shoes", 200);
    prices.put("Bag", 300);
    prices.put("Pant", 150);
    System.out.println("HashMap: " + prices);

    int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
    System.out.println("Price of Shirt: " + returnedValue);

    // 输出更新后的 HashMap
    System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shirt: 100
Updated HashMap: {Pant=150, Shirt=100, Bag=300, Shoes=200}

·compute() 方法

compute() 方法对 hashMap 中指定 key 的值进行重新计算。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        //创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往HashMap中添加映射项
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("HashMap: " + prices);

        // 重新计算鞋子打了10%折扣后的值
        int newPrice = prices.compute("Shoes", (key, value) -> value - value * 10/100);
        System.out.println("Discounted Price of Shoes: " + newPrice);

        // 输出更新后的HashMap
        System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Discounted Price of Shoes: 180
Updated HashMap: {Pant=150, Bag=300, Shoes=180

·computeIfAbsent() 方法

computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hashMap 中。

 1 import java.util.HashMap;
 2 
 3 class Main {
 4     public static void main(String[] args) {
 5         // 创建一个 HashMap
 6         HashMap<String, Integer> prices = new HashMap<>();
 7 
 8         // 往HashMap中添加映射项
 9         prices.put("Shoes", 200);
10         prices.put("Bag", 300);
11         prices.put("Pant", 150);
12         System.out.println("HashMap: " + prices);
13 
14         // 计算 Shirt 的值
15         int shirtPrice = prices.computeIfAbsent("Shirt", key -> 280);
16         System.out.println("Price of Shirt: " + shirtPrice);
17 
18         // 输出更新后的HashMap
19         System.out.println("Updated HashMap: " + prices);
20     }
21 }
22 执行以上程序输出结果为：
23 
24 HashMap: {Pant=150, Bag=300, Shoes=200}
25 Price of Shirt: 280
26 Updated HashMap: {Pant=150, Shirt=280, Bag=300, Shoes=200}

 

·computeIfPresent() 方法

computeIfPresent() 方法对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // 创建一个 HashMap
        HashMap<String, Integer> prices = new HashMap<>();

        // 往HashMap中添加映射关系
        prices.put("Shoes", 200);
        prices.put("Bag", 300);
        prices.put("Pant", 150);
        System.out.println("HashMap: " + prices);

        // 重新计算鞋加上10%的增值税后的价值
        int shoesPrice = prices.computeIfPresent("Shoes", (key, value) -> value + value * 10/100);
        System.out.println("Price of Shoes after VAT: " + shoesPrice);

        // 输出更新后的HashMap
        System.out.println("Updated HashMap: " + prices);
    }
}
执行以上程序输出结果为：

HashMap: {Pant=150, Bag=300, Shoes=200}
Price of Shoes after VAT: 220
Updated HashMap: {Pant=150, Bag=300, Shoes=220}}

 

LinkedList

链表

单向链表

就像我们工作一样

单向链表：手头干着活儿，盘算着明天的任务

包含两个值: 当前节点的值和一个指向下一个节点的链接

 

 

双向链表

双向链表：手头干着今天的活儿，想着昨天的工作总结，还盘算着明天的任务

有三个整数值: 数值、向后的节点链接、向前的节点链接

 

 

 为什么要看链表？？LinkedList的本身就是一个双向链表，ArrayList实质是顺序表，底层是一个数组。LinkedList实质是一个链表。

LinkedList用法

增加

 1 import java.util.LinkedList;
 2 
 3 public class RunoobTest {
 4     public static void main(String[] args) {
 5         LinkedList<String> sites = new LinkedList<String>();
 6         sites.add("Google");
 7         sites.add("Runoob");
 8         sites.add("Taobao");
 9         sites.add("Weibo");
10         System.out.println(sites);
11     }
12 }
13 以上实例，执行输出结果为：
14 
15 [Google, Runoob, Taobao, Weibo]

在列表开头添加元素

 1 // 引入 LinkedList 类
 2 import java.util.LinkedList;
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         LinkedList<String> sites = new LinkedList<String>();
 7         sites.add("Google");
 8         sites.add("Runoob");
 9         sites.add("Taobao");
10         // 使用 addFirst() 在头部添加元素
11         sites.addFirst("Wiki");
12         System.out.println(sites);
13     }
14 }
15 以上实例，执行输出结果为：
16 
17 [Wiki, Google, Runoob, Taobao]

在列表结尾添加元素

 1 // 引入 LinkedList 类
 2 import java.util.LinkedList;
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         LinkedList<String> sites = new LinkedList<String>();
 7         sites.add("Google");
 8         sites.add("Runoob");
 9         sites.add("Taobao");
10         // 使用 addLast() 在尾部添加元素
11         sites.addLast("Wiki");
12         System.out.println(sites);
13     }
14 }
15 以上实例，执行输出结果为：
16 
17 [Google, Runoob, Taobao, Wiki]

在列表开头移除元素：

 1 // 引入 LinkedList 类
 2 import java.util.LinkedList;
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         LinkedList<String> sites = new LinkedList<String>();
 7         sites.add("Google");
 8         sites.add("Runoob");
 9         sites.add("Taobao");
10         sites.add("Weibo");
11         // 使用 removeFirst() 移除头部元素
12         sites.removeFirst();
13         System.out.println(sites);
14     }
15 }
16 以上实例，执行输出结果为：
17 
18 [Runoob, Taobao, Weibo]

在列表结尾移除元素：

 1 // 引入 LinkedList 类
 2 import java.util.LinkedList;
 3 
 4 public class RunoobTest {
 5     public static void main(String[] args) {
 6         LinkedList<String> sites = new LinkedList<String>();
 7         sites.add("Google");
 8         sites.add("Runoob");
 9         sites.add("Taobao");
10         sites.add("Weibo");
11         // 使用 removeLast() 移除尾部元素
12         sites.removeLast();
13         System.out.println(sites);
14     }
15 }
16 以上实例，执行输出结果为：
17 
18 [Google, Runoob, Taobao]

迭代元素

for

// 引入 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");
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
    }
}
size() 方法用于计算链表的大小。

以上实例，执行输出结果为：

Google
Runoob
Taobao
Weibo

 for-each

// 引入 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");
        for (String i : sites) {
            System.out.println(i);
        }
    }
}
以上实例，执行输出结果为：

Google
Runoob
Taobao
Weibo

删除此列表中第一次出现的指定元素

public boolean removeFirstOccurrence​(Object o)

删除此列表中最后一次出现的指定元素

public boolean removeLastOccurrence​(Object o)
方法描述
public boolean add(E e) 链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public void add(int index, E element) 向指定位置插入元素。
public boolean addAll(Collection c) 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true，失败为 false。
public boolean addAll(int index, Collection c) 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true，失败为 false。
public void addFirst(E e) 元素添加到头部。
public void addLast(E e) 元素添加到尾部。
public boolean offer(E e) 向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
public boolean offerFirst(E e) 头部插入元素，返回是否成功，成功为 true，失败为 false。
public boolean offerLast(E e) 尾部插入元素，返回是否成功，成功为 true，失败为 false。
public void clear() 清空链表。
public E removeFirst() 删除并返回第一个元素。
public E removeLast() 删除并返回最后一个元素。
public boolean remove(Object o) 删除某一元素，返回是否成功，成功为 true，失败为 false。
public E remove(int index) 删除指定位置的元素。
public E poll() 删除并返回第一个元素。
public E remove() 删除并返回第一个元素。
public boolean contains(Object o) 判断是否含有某一元素。
public E get(int index) 返回指定位置的元素。
public E getFirst() 返回第一个元素。
public E getLast() 返回最后一个元素。
public int indexOf(Object o) 查找指定元素从前往后第一次出现的索引。
public int lastIndexOf(Object o) 查找指定元素最后一次出现的索引。
public E peek() 返回第一个元素。
public E element() 返回第一个元素。
public E peekFirst() 返回头部元素。
public E peekLast() 返回尾部元素。
public E set(int index, E element) 设置指定位置的元素。
public Object clone() 克隆该列表。
public Iterator descendingIterator() 返回倒序迭代器。
public int size() 返回链表元素个数。
public ListIterator listIterator(int index) 返回从指定位置开始到末尾的迭代器。
public Object[] toArray() 返回一个由链表元素组成的数组。
public T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组。

ArrayList与LinkList对比

 

 

 

 

 ArrayList是基于动态数组的数据结构。

因为是数组，所以ArrayList在初始化的时候，有初始大小10，插入新元素的时候，会判断是否需要扩容，扩容的步长是0.5倍原容量，扩容方式是利用数组的复制，因此有一定的开销；

1         int []  ints= new int[10];
2         System.out.println(ints.length);
3         //通过数组的copy 来实现数组的扩容
4         //参数一代表是需要扩容的数组名，参数二新数组的长度
5         int[] ints1 = Arrays.copyOf(ints, 20);
6         System.out.println(ints1.length);

另外，ArrayList在进行元素插入的时候，需要移动插入位置之后的所有元素，位置越靠前，需要位移的元素越多，开销越大，相反，插入位置越靠后的话，开销就越小了，如果在最后面进行插入，那就不需要进行位移；

LinkedList是采用双向链表实现的。所以它也具有链表的特点，每一个元素（结点）的地址不连续，通过引用找到当前结点的上一个结点和下一个结点，即插入和删除效率较高，只需要常数时间，而get和set则较为低效。

LinkedList的方法和使用和ArrayList大致相同，由于LinkedList是链表实现的，所以额外提供了在头部和尾部添加/删除元素的方法，也没有ArrayList扩容的问题了。另外，ArrayList和LinkedList都可以实现栈、队列等数据结构，但LinkedList本身实现了队列的接口，所以更推荐用LinkedList来实现队列和栈。

ArrayList和LinkedList的区别有以下几点：

 1.ArrayList是实现了基于动态数组的数据结构，而LinkedList是基于链表的数据结构；
 2.对于随机访问元素，Array获取数据的时间复杂度是O(1),但是要删除数据却是开销很大的，
　　因为这需要重排数组中的所有数据。ArrayList想要get(int index)元素时，直接返回
　　index位置上的元素，而LinkedList需要通过for循环进行查找，虽然LinkedList已经
　　在查找方法上做了优化，比如index < size / 2，则从左边开始查找，反之从右边开始查找，
　　但是还是比ArrayList要慢。
 3.对于添加和删除操作add和remove，LinkedList是更快的。因为LinkedList不像ArrayList
　　一样，不需要改变数组的大小，也不需要在数组装满的时候要将所有的数据重新装入一个新的数组，
　　这是ArrayList最坏的一种情况，时间复杂度是O(n)，而LinkedList中插入或删除的时间复杂
　　度仅为O(1)。ArrayList在插入数据时还需要更新索引（除了插入数组的尾部）。 ArrayList
　　想要在指定位置插入或删除元素时，主要耗时的是System.arraycopy动作，会移动index后面所
　　有的元素；LinkedList主耗时的是要先通过for循环找到index，然后直接插入或删除。这就导致
　　了两者并非一定谁快谁慢。

很多场景下都是ArrayList更受欢迎。但有些情况下LinkedList更为合适，比如：

1) 你的应用不会随机访问数据。因为如果你需要LinkedList中的第n个元素的时候，你需要从第一个元素顺序数到第n个数据，然后读取数据。

2) 你的应用有更多的插入和删除元素操作，更少的读取数据。因为插入和删除元素不涉及重排数据，所以它要比ArrayList要快。

描述算法复杂度时,常用o(1), o(n), o(logn), o(nlogn)表示对应算法的时间复杂度，是算法的时空复杂度的表示。不仅仅用于表示时间复杂度，也用于表示空间复杂度。
O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。
比如时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍。比如常见的遍历算法。再比如时间复杂度O(n2)，就代表数据量增大n倍时，耗时增大n的平方倍，这是比线性更高的时间复杂度。比如冒泡排序，就是典型的O(n2)的算法，对n个数排序，需要扫描n×n次。
再比如O(logn)，当数据增大n倍时，耗时增大logn倍（这里的log是以2为底的，比如，当数据增大256倍时，耗时只增大8倍，是比线性还要低的时间复杂度）。二分查找就是O(logn)的算法，每找一次排除一半的可能，256个数据中查找只要找8次就可以找到目标。
O(nlogn)同理，就是n乘以logn，当数据增大256倍时，耗时增大256*8=2048倍。这个复杂度高于线性低于平方。归并排序就是O(nlogn)的时间复杂度。
O(1)就是最低的时空复杂度了，也就是耗时/耗空间与输入数据大小无关，无论输入数据增大多少倍，耗时/耗空间都不变。 哈希算法就是典型的O(1)时间复杂度，无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话）

Iterator（迭代器）

Java迭代器（Iterator）是 Java 集合框架中的一种机制，它提供了一种在不暴露集合内部实现的情况下遍历集合元素的方法。

它是一种用于访问集合的方法，可用于迭代ArrayList 和HashSet 等集合。

Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。

 

 

 

迭代器 it 的三个基本操作是 next 、hasNext 和 remove。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

获取一个迭代器

集合想获取一个迭代器可以使用 iterator() 方法:

 1 // 引入 ArrayList 和 Iterator 类
 2 import java.util.ArrayList;
 3 import java.util.Iterator;
 4 
 5 public class RunoobTest {
 6     public static void main(String[] args) {
 7 
 8         // 创建集合
 9         ArrayList<String> sites = new ArrayList<String>();
10         sites.add("Google");
11         sites.add("Runoob");
12         sites.add("Taobao");
13         sites.add("Zhihu");
14 
15         // 获取迭代器
16         Iterator<String> it = sites.iterator();
17 
18         // 输出集合中的第一个元素
19         System.out.println(it.next());
20     }
21 }
22 执行以上代码，输出结果如下：
23 
24 Google

循环集合元素

让迭代器 it 逐个返回集合中所有元素最简单的方法是使用 while 循环：

 1 // 引入 ArrayList 和 Iterator 类
 2 import java.util.ArrayList;
 3 import java.util.Iterator;
 4 
 5 public class RunoobTest {
 6     public static void main(String[] args) {
 7 
 8         // 创建集合
 9         ArrayList<String> sites = new ArrayList<String>();
10         sites.add("Google");
11         sites.add("Runoob");
12         sites.add("Taobao");
13         sites.add("Zhihu");
14 
15         // 获取迭代器
16         Iterator<String> it = sites.iterator();
17 
18         // 输出集合中的所有元素
19         while(it.hasNext()) {
20             System.out.println(it.next());
21         }
22     }
23 }
24 执行以上代码，输出结果如下：
25 
26 Google
27 Runoob
28 Taobao
29 Zhihu

删除元素

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<Integer>();
        numbers.add(12);
        numbers.add(8);
        numbers.add(2);
        numbers.add(23);
        Iterator<Integer> it = numbers.iterator();
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  //  remove() 方法,删除小于 10 的元素
            }
        }
        System.out.println(numbers);
    }
}
执行以上代码，输出结果如下：

[12, 23]

 

posted @ 2023-03-22 14:46  这里那里  阅读(60)  评论(0)    收藏  举报
Live2D