集合 API04 8.25

集合02 8.25

List集：
- 继承Collection接口
- 常见的实现类：
  - 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接口
- 不可重复，无序

package com.mlyStudyJava.APIday04;

import java.util.*;

/*
List集合
 */
public class List01 {
    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);
        System.out.println("=====================");
        System.out.println("=========标准for============");
        for (int i = 0; i <List.size() ; i++) {
            System.out.println(List.get(i));
        }
        System.out.println("=========增强for============");
        for (String s : List){
            System.out.println(s);
        }
        System.out.println("=========迭代器============");
        Iterator<String> it = List.iterator();
        while (it.hasNext()) {
            Object next =  it.next();
            System.out.println(next);
        }

        System.out.println("=====================");
        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 集合的工具类，包括集合相关的方法
         */
        System.out.println("=====================");
        Collections.reverse(List);//反转List集合元素(下标变化了)
        System.out.println(List);//[five, four, six, two, one]
        System.out.println("=====================");
        List.add(3,"three");
        System.out.println(List);//[five, four, six, three, two, one]
        System.out.println("=====================");
       /*
       E remove(int index)
       删除指定位置元素，并返回指定位置元素
        */
        String old1 =List.remove(2);//常规写法
        System.out.println(List);
        System.out.println(old1);


    }
}

package com.mlyStudyJava.APIday04;

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

/**
 * List提供了获取子集的操作：
 * List subList(int start , int end):含头不含尾[start,end)
 */
public class List02 {
    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]

        System.out.println("==================");
        //将子集每个元素都扩大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);
        //原集合修改后，子集不能再操作了，但是可以重写获取子集
        //System.out.println(sublist); //发生不支持异常修改ConcurrentModificationException



    }
}

package com.mlyStudyJava.APIday04;

import java.util.Arrays;
import java.util.List;

/**
 * 数组转集合
 */
public class List03 {
    public static void main(String[] args) {
        String[] array ={"one","two","three","four","five"};
        System.out.println("array:"+ Arrays.toString(array));
        //将数组转换为集合asList()，存储了数组的引用，指向了同一个对象
        List<String> list = Arrays.asList(array);
        System.out.println("List: "  +list);
        System.out.println("===========================");
        //修改数组会影响集合
        array[2] ="six";
        System.out.println("array:"+Arrays.toString(array));
        System.out.println("list: " +list);
        System.out.println("===========================");
        //修改集合也会影响集合 集合->数组；集合<-数组；双向链表
        list.set(3,"seven");
        System.out.println("array:"+Arrays.toString(array));
        System.out.println("list: " +list);


    }
}

去重算法

package com.mlyStudyJava.APIday04;

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

/**
 * Set集 不可重复，无序
 */
public class More {
    public static void main(String[] args) {
//
//        Set<String> set =new HashSet<>();
//        set.add("one");
//        set.add("two");
//        set.add("three");
//        set.add("four");
//        set.add("five");
        ArrayList<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("two");
        list.add("four");
        System.out.println("原列表："+list);
        System.out.println("============");
        Set<String> set = new HashSet<>();
        set.addAll(list);
        System.out.println("去重后的set:"+set);

//   所谓的去重算法： 先把字符串放入list，再从list放到set




    }
}

list比较，写构造方法

package com.mlyStudyJava.APIday04;

import java.util.Objects;

public class Point implements Comparable<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);
    }

    @Override
    public int compareTo(Point o) {
        return 1;
    }
}

排序

package com.mlyStudyJava.APIday04;

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

public class SortList01 {
    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);
        System.out.println("=====从大到小反转======");
        Collections.reverse(list);//数据已经变化了
        System.out.println("list反转后："+list);
    }
}

package com.mlyStudyJava.APIday04;

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

/**
 * 排序字符串
 */
public class SortList02 {
    public static void main(String[] args) {
//        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);
//        System.out.println("=======================");
//        Collections.sort(list);
//        System.out.println("list排序后数据："+list);
//        //对英文字符串排序，以ASCII码顺序排序，大写在前
//        //若首字母相同，比较第2个字符的ASCII码，以此类推
        List<String> list = new ArrayList<>();
        list.add("王克晶");
        list.add("传奇");
        list.add("苍老师");
        list.add("国斌");
        System.out.println("list原始数据："+list);
        Collections.sort(list, new Comparator<String>() {
            @Override
            /*
            compare(String o1, String o2) 用于比较o1和o2，并用返回值表示大小
            1.如果return >0,o1>o2 前大后小则交换，可以排序后前小到大
            2.如果return <0,o1<o2 前小后大则交换，可以排序后前大到小
            o1.length()-o2.length() >0升序
             */
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        System.out.println("=====================");
        /*
        Collections.sort(list list)
        该方法要求List集合中的元素必须是可比较的
        */
        System.out.println("list排序后数据："+list);
        System.out.println("王："+(int)'王');
        System.out.println("传："+(int)'传');
        System.out.println("国："+(int)'国');
        System.out.println("苍："+(int)'苍');




    }
}

package com.mlyStudyJava.APIday04;

import com.sun.org.apache.bcel.internal.generic.ARETURN;

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

/*
排序自定义
 */
public class SortList03 {
    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,list)
        该方法要求list集合中的元素必须是可比较的。
        若不可比较，编译报错不允许排序
        判定是否可比较的标准是元素是否实现了 java.util.Comparable接口

        实际开发中，我们并不会让我们自己定义的类去实现Comparable接口，对程序有侵入性，安全性不高
        侵入性：当我们调用某个API功能，其要求我们为其修改其他额外代码。侵入性越强越不利于后续业务的维护。

         */
//        Collections.sort(list);
//        System.out.println(list);
        Collections.sort(list, new Comparator<Point>() {
            @Override
            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 o1.getX()-o2.getX();//按x坐标升序
                //return o2.getY()-o1.getY(); 按y坐标降序
            }
        });
        System.out.println("=================");
        System.out.println(list);
        //jdk1.8 List集合自身提供了sort方法进行排序，sort方法仍然需要传入比较器
        list.sort(new Comparator<Point>() {
            @Override
            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;//升序
            }
        });
        System.out.println(list);
    }
}

posted @ 2022-08-25 19:45 luyi_ma 阅读(22) 评论(0) 收藏举报

刷新页面返回顶部

maluyi

集合 API04 8.25

集合02 8.25

公告