JavaBeans：List、Set、集合的工具类Collections

回顾：

什么是集合：
java.util.Collection接口：所有集合的顶级接口，下面有两个子接口：List、Set
Collection接口中的常用方法：
- add()：添加元素
- size()：获取集合元素个数
- isEmpty()：判断当前集合是否为空集(size()为0即为空集)
- clear()：清空集合
- contains()：判断集合是否包含给定元素
- remove()：删除给定元素
- addAll()：将一个集合添加到另一个集合中
- containsAll()：判断一个集合是是否包含另一个集合的所有元素
- removeAll()：删交集
- retainAll()：取交集
遍历集合：迭代器Iterator接口，步骤：问(hasNext())、取(next())、删(remove())，其中删并不是必要操作
增强for/新循环：jdk1.5推出的，使用相同的语法遍历集合和数组
泛型：限定数据类型
数组与集合间的转换：
- 数组转换为List集合：asList()
- 集合转换为数组：toArray()

精华笔记：

List接口：
- 继承自Collection接口，List集合是可重复集合，并且有序，并且提供了一套可以通过下标操作元素的方法
- 常见的实现类：
  - java.util.ArrayList：内部使用数组实现，查询性能更好(直接下标查找)、增删性能不太好
  - java.util.LinkedList：内部使用链表实现，查询性能不太好，首尾增删元素性能更好
    
    注意：在对集合操作的性能没有特别苛刻要求时，通过选择ArrayList。
List集合常见方法：
- get()：根据下标获取元素
- set()：将指定元素设置到指定位置，并返回被替换的元素(用时接收)
- 重载add()：将指定元素添加到指定位置，理解为插入操作
- 重载remove()：删除并返回指定位置元素
- subList()：获取当前集合中指定范围内的子集(含头不含尾)
集合的排序：
- Collections是集合的工具类，里面定义了很多静态方法用于操作集合
- Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，Collections.sort(List list)方法要求List集合中的元素必须是可比较的，若不可比较则直接发生编译错误，不允许排序。判定是否可比较的标准为元素是否实现了java.util.Comparable接口。实际开发中，我们并不会让我们自己定义的类去实现Comparable接口的，因为这对我们的程序有侵入性。
  
  侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性越强则越不利于程序的后期维护，应尽量避免。
- 建议使用重载的Collections.sort(List list, Comparator c)方法，可以通过Comparator来自定义规则
Set接口：
- 继承自Collection接口，元素是不可重复的，并且是无序的
- 常见的实现类：
  - HashSet类：

笔记：

List接口：
- 继承自Collection接口，List集合是可重复集合，并且有序，并且提供了一套可以通过下标操作元素的方法
- 常见的实现类：
  - java.util.ArrayList：内部使用数组实现，查询性能更好(直接下标查找)、增删性能不太好
  - java.util.LinkedList：内部使用链表实现，查询性能不太好，首尾增删元素性能更好
    
    注意：在对集合操作的性能没有特别苛刻要求时，通过选择ArrayList。

List集合常见方法：

get()：根据下标获取元素
set()：将指定元素设置到指定位置，并返回被替换的元素(用时接收)
重载add()：将指定元素添加到指定位置，理解为插入操作

重载remove()：删除并返回指定位置元素

package apiday04;

import java.util.*;

/**
 * List集合:
 * 1.List接口中提供了一套可以通过下标操作元素的方法
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println("list:"+list.toString());

        /*
          E get(int index):
          获取指定下标所对应的元素
         */
        String e = list.get(2);
        System.out.println(e); //three
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        for(String s : list){
            System.out.println(s);
        }
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println("----------------------------------");

        /*
          E set(int index, E e)
          将给定元素设置到指定位置，返回被替换的元素
         */
        String old = list.set(2,"six"); //将list中下标为2的元素设置为six
        //list.set(2,"six"); //常规用法
        System.out.println(list); //[one, two, six, four, five]
        System.out.println(old);

        /*
          java.util.Collections为集合的工具类，包含了集合相关的静态方法
         */
        Collections.reverse(list); //反转list集合元素(下标变化了)
        System.out.println(list); //[five, four, six, two, one]

        /*
         * void add(int index, E e)
         * 将给定元素e添加到index所指定的位置，相当于插入操作
         */
        list.add(3,"three");
        System.out.println(list); //[five, four, six, three, two, one]

        /*
          E remove(int index)
          删除指定位置元素，并返回指定位置元素
         */
        String o = list.remove(2);
        //list.remove(2); //常规操作
        System.out.println(list); //[five, four, three, two, one]
        System.out.println(o); //six
    }
}

subList()：获取当前集合中指定范围内的子集(含头不含尾)

package apiday04;

import java.util.ArrayList;
import java.util.List;

/**
 * List提供了获取子集的操作:
 * List subList(int start,int end): 含头不含尾
 */
public class ListDemo2 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i*10); //自动装箱
        }
        System.out.println(list); //[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

        //获取下标3到7的子集
        List<Integer> subList = list.subList(3,8);
        System.out.println(subList); //[30, 40, 50, 60, 70]

        //将子集每个元素都扩大10倍
        for(int i=0;i<subList.size();i++){
            subList.set(i,subList.get(i)*10);
        }
        System.out.println(subList); //[300, 400, 500, 600, 700]

        //注意:对子集的操作就是对原集合对应元素操作
        System.out.println(list); //[0, 10, 20, 300, 400, 500, 600, 700, 80, 90]

        list.remove(0);
        System.out.println(list); //[10, 20, 300, 400, 500, 600, 700, 80, 90]
        //原集合修改之后，子集将不能再进行操作了，操作则发生异常，但是可以重新获取子集
        //System.out.println(subList); //发生不支持修改异常

    }
}

集合的排序：

Collections是集合的工具类，里面定义了很多静态方法用于操作集合

package apiday04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
 * 集合的排序
 */
public class SortListDemo {
    public static void main(String[] args) {
        Random rand = new Random();
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(rand.nextInt(100));
        }
        System.out.println("list原始数据:"+list);

        Collections.sort(list); //自然排序(从小到大)
        System.out.println("list排序后数据:"+list);

        Collections.reverse(list); //反转list集合(数据已经变化了)
        System.out.println("list反转后:"+list);

    }
}

Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，Collections.sort(List list)方法要求List集合中的元素必须是可比较的，若不可比较则直接发生编译错误，不允许排序。判定是否可比较的标准为元素是否实现了java.util.Comparable接口。实际开发中，我们并不会让我们自己定义的类去实现Comparable接口的，因为这对我们的程序有侵入性。

侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性越强则越不利于程序的后期维护，应尽量避免。

重载的Collections.sort(List list, Comparator c)方法，可以通过Comparator来自定义规则

package apiday04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 字符串的排序
 */
public class SortListDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("王克晶");
        list.add("传奇afsadsfsdaf");
        list.add("国斌老师");
        System.out.println("list原始数据:"+list);

        //自定义排序规则:
        Collections.sort(list, new Comparator<String>() {
            /*
              compare()方法用于定义o1和o2比较大小的规则，并用返回值表达大小关系
              返回值实现的要求:-------不用纠结，去记下面的结论
              1)如果返回值>0则表达的是o1>o2
              2)如果返回值<0则表达的是o1<o2
              3)如果返回值=0则表达的是o1=o2
              结论:
                1)前面的-后面的----------升序
                2)后面的-前面的----------降序
             */
            public int compare(String o1, String o2) {
                return o1.length()-o2.length(); //升序
                //return o2.length()-o1.length(); //降序
            }
        });
        System.out.println("list排序后数据:"+list);
        /*
        List<String> list = new ArrayList<>();
        list.add("jack");
        list.add("rose");
        list.add("tom");
        list.add("black");
        list.add("jerry");
        list.add("Kabe");
        System.out.println("list原始数据:"+list);
        //对英文字符串排序时，会按首字母的ASCII码排序
        //若首字母相同，则比较第2个字符的ASCII码，以此类推
        Collections.sort(list);
        System.out.println("list排序后数据:"+list);
        */
    }
}

package apiday04;

import java.util.Objects;

/**
 * 点
 */
public class Point{
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ')';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

package apiday04;

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

/**
 * 排序自定义类型
 */
public class SortListDemo3 {
    public static void main(String[] args) {
        List<Point> list = new ArrayList<>();
        list.add(new Point(5,8));
        list.add(new Point(15,60));
        list.add(new Point(56,50));
        list.add(new Point(1,4));
        list.add(new Point(9,6));
        list.add(new Point(99,88));
        System.out.println(list);

        /*
        Collections.sort(list, new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
                int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
                return len1-len2; //升序
                //return len2-len1; //降序

                //return o1.getX()-o2.getX(); //按x坐标升序
                //return o2.getY()-o1.getY(); //按y坐标降序
            }
        });
        System.out.println(list);
         */

        //jdk1.8，List集合自身提供了sort方法进行排序，sort方法依然需要传入比较器
        list.sort(new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
                int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
                return len1-len2; //升序
                //return len2-len1; //降序
            }
        });
        System.out.println(list);

    }
}

Set接口：

继承自Collection接口，元素是不可重复的，并且是无序的

常见的实现类：

HashSet类：

package apiday04;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Set集: 不可重复集合、并且无序
 */
public class SetDemo {
    public static void main(String[] args) {
        //小面试题: 如何去重?
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("two");
        System.out.println(list);

        Set<String> set = new HashSet<>();
        set.addAll(list);
        System.out.println(set);

        /*
        Set<String> set = new HashSet<>();
        set.add("one");
        set.add("two");
        set.add("three");
        set.add("four");
        set.add("five");
        set.add("two");
        set.add("five");
        System.out.println(set);
        */

    }
}

posted @ 2022-09-12 20:28 Little_Monster-lhq 阅读(217) 评论(0) 编辑收藏举报

刷新页面返回顶部

little-monster-lhq

JavaBeans：List、Set、集合的工具类Collections

回顾：

精华笔记：

笔记：

公告