百木园-与人分享，
就是让自己快乐。
当前位置：百木园 > 野生技术 > 正文

集合框架（Collections工具类的方法使用----ArrayList集合存储自定义对象的排序和去除元素重复值）

2022-03-29 分类：野生技术 阅读(235) 评论(0) 
 Collections:是针对集合进行操作的工具类，都是静态方法。
*
* 面试题：
* Collection和Collections的区别?
* Collection:是单列集合的顶层接口，有子接口List和Set。
* Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
*
* 要知道的方法
* public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
* public static <T> int binarySearch(List<?> list,T key):二分查找--集合必须是排序后的元素
* public static <T> T max(Collection<?> coll):最大值
* public static void reverse(List<?> list):反转
* public static void shuffle(List<?> list):随机置换

 1 package Day18;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.List;
 6 
 7 /*
 8  * Collections:是针对集合进行操作的工具类，都是静态方法。
 9  *
10  * 面试题：
11  * Collection和Collections的区别?
12  * Collection:是单列集合的顶层接口，有子接口List和Set。
13  * Collections:是针对集合操作的工具类，有对集合进行排序和二分查找的方法
14  *
15  * 要知道的方法
16  * public static <T> void sort(List<T> list)：排序 默认情况下是自然顺序。
17  * public static <T> int binarySearch(List<?> list,T key):二分查找--集合必须是排序后的元素
18  * public static <T> T max(Collection<?> coll):最大值
19  * public static void reverse(List<?> list):反转
20  * public static void shuffle(List<?> list):随机置换
21  */
22 public class Map13 {
23     public static void main(String[] args) {
24         //首先定义一个List集合----子类可以实现父类，但是父类不可以实现子类
25         List<Integer> list = new ArrayList<Integer>();
26         //向集合中添加元素
27         list.add(20);
28         list.add(70);
29         list.add(40);
30         list.add(87);
31         //进行输出查看list集合
32         //System.out.println(list);
33 
34         //对List集合使用Collections工具类进行自然排序
35         Collections.sort(list);
36         //对自然排序后的集合进行输出查看
37         //System.out.println(list);
38 
39         //对排序后的集合进行二分查找---查找元素在集合中的索引值
40         // public static <T> int binarySearch(List<?> list,T key):二分查找--集合必须是排序后的元素
41         System.out.println(Collections.binarySearch(list,20));
42         //如果查找到元素不在集合中---测输出的索引值是集合长度加1再添一个负号
43         System.out.println(Collections.binarySearch(list,700));
44 
45         //使用集合Collections工具类进行输出List集合中的最大值
46         //public static <T> T max(Collection<?> coll):最大值
47         System.out.println(Collections.max(list));
48 
49         //使用Collections集合工具对List集合进行反转
50         //public static void reverse(List<?> list):反转
51         Collections.reverse(list);
52         //输出查看集合是否反转
53         System.out.println(list);
54 
55 
56         //使用针对集合操作的Collections集合操作类进行对List集合的置换
57         //public static void shuffle(List<?> list):随机置换
58         Collections.shuffle(list);
59         //进行集合的输出查看--是否随机置换
60         System.out.println(list);
61 
62 
63     }
64 }

ArrayList集合存储自定义对象的排序和去除元素重复值

使用工具：Collections.sort（）-----使用比较器排序

去除重复值：

A:   创建新集合

B：Iterator---创建迭代器对象---（hasNext判断和next获取）--boolean contains(Object o)：判断集合中是否包含指定的元素----重写学生类中的equals方法

学生类
package Day18;

import java.util.Objects;

//学生类实现Comparable接口并给出泛型是Student
public class Student implements  Comparable<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;
    }

    //重写Comparable下的CompareTo方法---自然排序
    public int compareTo(Student m){
        //首选按照年龄进行排序
        int num = this.age -m.age;
        //年龄相同进行姓名的排序----compareTo自然排序
        int num1 = num==0? this.name.compareTo(m.name) : num;
        return num1;
    }

  //重写contains下的equals---因为默认contains的equals默认的是Object下的equals
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return getAge() == student.getAge() &&
                Objects.equals(getName(), student.getName());
    }


}




//    //重写HashCode和equals方法
//    //使Set集合输出时不会出现重复值
//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (!(o instanceof Student)) return false;
//        Student student = (Student) o;
//        return getAge() == student.getAge() &&
//                Objects.equals(getName(), student.getName());
//    }
//
//    @Override
//    public int hashCode() {
//        return Objects.hash(getName(), getAge());
//    }


 






 实现类


package Day18;

import java.util.*;

/*
* ArrayList集合存储自定义对象并排序和去除集合中的元素重复值
*
*
*
* */
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生类对象
        Student A = new Student(\"林青霞\", 27);
        Student B = new Student(\"刘备\", 29);
        Student C = new Student(\"关羽\", 30);
        Student D = new Student(\"林青霞\", 27);
        Student E = new Student(\"林青霞\", 31);

        //将学生对象添加到集合中
        list.add(A);
        list.add(B);
        list.add(C);
        list.add(D);
        list.add(E);

        //对集中元素进行排序按照年龄
        //此时的Collections的sort方法不能直接对存储的对象直接进行排序
//        //需要学生类实现Comparable接口并重写CompareTo方法---------实现其自然排序
//        Collections.sort(list);
//        //直接输出list集合--输出的结果是每个对象的地址
//        System.out.println(list);
//        //遍历输出查看排序后的集合元素
//        for(Student e:list){
//            //获取学生对象的各个元素数据
//            System.out.println(e.getName()+\"---\"+e.getAge());
//        }

        //对集中元素进行排序按照年龄
        //此时的Collections的sort方法不能直接对存储的对象直接进行排序
        //使用比较器器进行排序
        Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄进行排序--倒序
                int num = o2.getAge() - o1.getAge();
                int num1 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num1;
            }
        });
/**
 *   /*
 *      * 创建新集合将重复元素去掉-------重写对象的equals方法
 *      * 1,明确返回值类型,返回ArrayList
 *      * 2,明确参数列表ArrayList
 *      *
 *      * 分析:
 *      * 1,创建新集合
 *      * 2,根据传入的集合(老集合)获取迭代器
 *      * 3,遍历老集合
 *      * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
// * */

        //创建一个新的集合
        ArrayList AA = new ArrayList();
        //遍历旧集合--获取集合中的元素
        //利用集合对象创建迭代器对象
        Iterator it = list.iterator();
        while (it.hasNext()) {
            //进行旧集合数据的获取--并转化为学生类
            Student ss = (Student) it.next();
            //进行if条件的判断
            //boolean contains(Object o)：判断集合中是否包含指定的元素
            //面对自定义对象需要重写对象类中的equals方法--才可成功
            if (!AA.contains(ss)) {
                AA.add(ss);
            }
        }
        //去除后遍历新的集合输出
        //遍历新集合
        for (int x = 0; x < AA.size(); x++) {
            //public E get(int index)返回此列表中指定位置上的元素
           Student tt =(Student) AA.get(x);
            System.out.println(tt.getName()+\"---\"+tt.getAge());
        }
    }
}


 


package Day18;

import java.util.*;

/*
* ArrayList集合存储自定义对象并排序和去除集合中的元素重复值
*
*
*
* */
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建集合对象
List<Student> list = new ArrayList<Student>();
//创建学生类对象
Student A = new Student(\"林青霞\", 27);
Student B = new Student(\"刘备\", 29);
Student C = new Student(\"关羽\", 30);
Student D = new Student(\"林青霞\", 27);
Student E = new Student(\"林青霞\", 31);

//将学生对象添加到集合中
list.add(A);
list.add(B);
list.add(C);
list.add(D);
list.add(E);

//对集中元素进行排序按照年龄
//此时的Collections的sort方法不能直接对存储的对象直接进行排序
//        //需要学生类实现Comparable接口并重写CompareTo方法---------实现其自然排序
//        Collections.sort(list);
//        //直接输出list集合--输出的结果是每个对象的地址
//        System.out.println(list);
//        //遍历输出查看排序后的集合元素
//        for(Student e:list){
//            //获取学生对象的各个元素数据
//            System.out.println(e.getName()+\"---\"+e.getAge());
//        }

        //对集中元素进行排序按照年龄
//此时的Collections的sort方法不能直接对存储的对象直接进行排序
//使用比较器器进行排序
Collections.sort(list, new Comparator<Student>() {
            @Override
public int compare(Student o1, Student o2) {
                //按照年龄进行排序--倒序
int num = o2.getAge() - o1.getAge();
                int num1 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num1;
}
        });
/**
 *   /*
 *      * 创建新集合将重复元素去掉-------重写对象的equals方法
*      * 1,明确返回值类型,返回ArrayList
 *      * 2,明确参数列表ArrayList
 *      *
 *      * 分析:
 *      * 1,创建新集合
*      * 2,根据传入的集合(老集合)获取迭代器
*      * 3,遍历老集合
*      * 4,通过新集合判断是否包含老集合中的元素,如果包含就不添加,如果不包含就添加
// * */

//创建一个新的集合
ArrayList AA = new ArrayList();
//遍历旧集合--获取集合中的元素
//利用集合对象创建迭代器对象
Iterator it = list.iterator();
        while (it.hasNext()) {
            //进行旧集合数据的获取--并转化为学生类
Student ss = (Student) it.next();
//进行if条件的判断
//boolean contains(Object o)：判断集合中是否包含指定的元素
//面对自定义对象需要重写对象类中的equals方法--才可成功
if (!AA.contains(ss)) {
                AA.add(ss);
}
        }
        //去除后遍历新的集合输出
//遍历新集合
for (int x = 0; x < AA.size(); x++) {
            //public E get(int index)返回此列表中指定位置上的元素
Student tt =(Student) AA.get(x);
System.out.println(tt.getName()+\"---\"+tt.getAge());
}
    }
}




来源：https://www.cnblogs.com/ztg-java-xuexi/p/16070999.html

本站部分图文来源于网络，如有侵权请联系删除。

		

										
未经允许不得转载：百木园 » 集合框架（Collections工具类的方法使用----ArrayList集合存储自定义对象的排序和去除元素重复值）
		
					

		
		
标签：

		
		
		            
        
				
相关推荐
  • 暂无文章
					

	

	


热门文章