JavaSE基础知识复习【06】

71 阅读 0 评论 47 点赞

我是靠谱客的博主执着帽子，最近开发中收集的这篇文章主要介绍JavaSE基础知识复习【06】，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

前言

朝八晚八

正文

1、List集合

java.util.List接口 extends Collection接口
List接口的特点：
1. 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
2. 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
3. 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
List接口中带索引的方法（特有）

public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。
public E get(int index):返回集合中指定位置的元素。
public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
注意：
操作索引的时候，一定要防止索引越界异常
IndexOutOfBoundsException：索引越界异常，集合会报
ArrayIndexOutOfBoundsException：数组索引越界异常
StringIndexOutOfBoundsException：字符串索引越界异常

2、List的子类

ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
【LinkedList是一个双向链表】，实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：

public void addFirst(E e):将指定元素插入此列表的开头。
public void addLast(E e):将指定元素添加到此列表的结尾。
public E getFirst():返回此列表的第一个元素。
public E getLast():返回此列表的最后一个元素。
public E removeFirst():移除并返回此列表的第一个元素。
public E removeLast():移除并返回此列表的最后一个元素。
public E pop():从此列表所表示的堆栈处弹出一个元素。
public void push(E e):将元素推入此列表所表示的堆栈。
public boolean isEmpty()：如果列表不包含元素，则返回true。

LinkedList是List的子类，List中的方法LinkedList都是可以使用，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

Vector集合

Vector是同步的，如果一个线程安全的实现是不需要的，建议在使用Vector的地方用ArrayList替换。

3、Set接口

java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
tips:【Set集合取出元素的方式可以采用：迭代器、增强for】。

4、HashSet集合

java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap支持。HashSet是根据对象的哈希值来确定元素在集合中的存储位置，因此具有良好的存取和查找性能。保证元素唯一性的方式依赖于：hashCode与equals方法。

java.util.Set接口 extends Collection接口
     Set接口的特点：
         1.不允许存储重复的元素
         2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
     java.util.HashSet集合 implements Set接口
     HashSet特点：
         1.不允许存储重复的元素
         2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历
         3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致
         4.底层是一个哈希表结构（查询的速度非常的快）

【HashSet集合存储数据的结构—哈希表】

在这里插入图片描述
【哈希存储流程图】

【HashSet存储不重复元素的原理】
在这里插入图片描述

保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式

5、LinkedHashSet

HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序则需要使用LinkedHashSet。在HashSet下面有一个子类java.util.LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点：
底层是一个【哈希表（数组+链表/红黑树）+链表】：相较于HashSet多了一条链表（记录元素的存储顺序），从而来保证元素有序

6、可变参数

可变参数：JDK1.5以后。出现了简化操作。… 用在参数上，称之为可变参数。
同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

使用前提：
当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数
使用格式：
修饰符返回值类型方法名(参数类型... 形参名){ }
其实这个书写完全等价于
修饰符返回值类型方法名(参数类型[] 形参名){ }
只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。
可变参数的原理：
可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数
传递的参数个数，可以是0个（不传递），1,2,…多个
注意事项：
1.如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。
2.一个方法的参数列表，只能有一个可变参数

7、Collections工具类

java.utils.Collections是集合工具类，用来对集合进行操作。部分方法如下：

public static <T> boolean addAll(Collection<T> c, T... elements):往集合中添加一些元素。
public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。
public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序。

说到排序了，简单的说就是两个对象之间比较大小，那么在JAVA中提供了两种比较实现的方式，一种是比较死板的采用java.lang.Comparable接口去实现，一种是灵活的当我需要做排序的时候再去选择的java.util.Comparator接口完成。
那么我们采用的public static <T> void sort(List<T> list)这个方法完成的排序，实际上要求了被排序的类型需要实现Comparable接口完成比较的功能，在String类型上如下：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {

String类实现了这个接口，并完成了比较规则的定义，但是这样就把这种规则写死了，那比如我想要字符串按照第一个字符降序排列，那么这样就要修改String的源代码，这是不可能的了，那么这个时候我们可以使用
public static <T> void sort(List<T> list，Comparator<? super T> )方法灵活的完成，这个里面就涉及到了Comparator这个接口，位于位于java.util包下，排序是comparator能实现的功能之一,该接口代表一个比较器，比较器具有可比性！顾名思义就是做排序的，通俗地讲需要比较两个对象谁排在前谁排在后，那么比较的方法就是：
public int compare(String o1, String o2)：比较其两个参数的顺序。
【升序】：o1-o2 前者减后者
【降序】：o2-o1 后者减前者
两个对象比较的结果有三种：大于，等于，小于。

如果要按照升序排序,
则o1 小于o2，返回（负数），相等返回0，o1大于o2返回（正数）
如果要按照降序排序
则o1 小于o2，返回（正数），相等返回0，o1大于o2返回（负数）

操作如下：

public class CollectionsDemo3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        list.add("cba");
        list.add("aba");
        list.add("sba");
        list.add("nba");
        //排序方法  按照第一个字母的降序
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0) - o1.charAt(0);
            }
        });
        System.out.println(list);//[sba, nba, cba, aba]
    }
}

【Comparable和Comparator两个接口的区别】

Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

Comparator强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

测试Demo

//自定义学生类
public class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
               "name='" + name + ''' +
               ", age=" + age +
               '}';
    }
}


//测试类
public class Demo {
    public static void main(String[] args) {
        // 创建四个学生对象 存储到集合中
        ArrayList<Student> list = new ArrayList<Student>();

        list.add(new Student("rose",18));
        list.add(new Student("jack",16));
        list.add(new Student("abc",16));
        list.add(new Student("ace",17));
        list.add(new Student("mark",16));

     
		Collections.sort(list, new Comparator<Student>() {
    		@Override
    		public int compare(Student o1, Student o2) {
        		return o2.getAge()-o1.getAge();//以学生的年龄降序
    		}
		});
		
        for (Student student : list) {
            System.out.println(student);
        }
        /*
		Student{name='rose', age=18}
		Student{name='ace', age=17}
		Student{name='jack', age=16}
		Student{name='abc', age=16}
		Student{name='mark', age=16}
		*/
    }
}

扩展：如果想要规则更多一些，可以参考下面代码：

Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                // 年龄降序
                int result = o2.getAge()-o1.getAge();//年龄降序

                if(result==0){//第一个规则判断完了 下一个规则 姓名的首字母 升序
                    result = o1.getName().charAt(0)-o2.getName().charAt(0);
                }

                return result;
            }
        });

测试结果如下：

Student{name='rose', age=18}
Student{name='ace', age=17}
Student{name='abc', age=16}
Student{name='jack', age=16}
Student{name='mark', age=16}

最后

以上就是执着帽子为你收集整理的JavaSE基础知识复习【06】的全部内容，希望文章能够帮你解决JavaSE基础知识复习【06】所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：# JavaSE
浏览次数：71 次浏览
发布日期：2023-09-03 10:40:41
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_10_fy_14__7__6_z.html

JavaSE基础知识复习【06】

概述

前言

正文

1、List集合

2、List的子类

ArrayList集合

LinkedList集合

Vector集合

3、Set接口

4、HashSet集合

5、LinkedHashSet

6、可变参数

7、Collections工具类

最后

评论列表共有 0 条评论

发表评论取消回复

JavaSE基础知识复习【06】

概述

前言

正文

1、List集合

2、List的子类

ArrayList集合

LinkedList集合

Vector集合

3、Set接口

4、HashSet集合

5、LinkedHashSet

6、可变参数

7、Collections工具类

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复