Java SE基础知识（12）

最新推荐文章于 2024-05-12 17:13:06 发布

芝士仙贝多多

最新推荐文章于 2024-05-12 17:13:06 发布

阅读量202

点赞数

本文链接：https://blog.csdn.net/TuZiBuQing/article/details/107852504

版权

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);

    }
}