List Set Java数据结构初级 Collections比较器 D190325

List Set Java数据结构初级 Collections比较器

今天学习的比较繁杂,及时理解消化

01.回顾_Java集合体系框架:
A).Collection(接口):单列集合:
|–List(接口):特点:1).有序的;2).可以存储重复元素;3).可以通过索引访问元素
|–ArrayList(子类)
|–LinkedList(子类)
|–Set(接口):特点:1).无序的;2).不能存储重复元素;3).不能索引访问元素;
|–HashSet(子类):
|–LinkedHashSet(子类):
B).Map(接口):双列集合

02.第一章:List集合:
1).特点:
1).有序的;
2).可以存储重复元素;
3).可以通过索引访问元素
2).List接口中的新增的方法:
添加:
1).public void add(int index, E element) : 将指定的元素,添加到该集合中的指定位置上。
查询:
2).public E get(int index) :返回集合中指定位置的元素。
删除:
3).public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
修改:
4).public E set(int index, E element) :用指定元素替换集合中指定位置的元素,
返回值的更新前的元素。
注意:
1).上面的四个方法有个共同的特征,都带"索引"的参数。
2).上面的四个方法,在使用索引时,必须保证索引的正确,否则会抛异常;

            List<String> list = new ArrayList<>();
			System.out.println(list.get(0));//抛异常
			System.out.println(list.remove(0));//抛异常

03.第二章:数据结构:
1).各种不同的集合类,采用了不同的“存储数据的方式”,这种存储数据的方式就叫:数据结构。
2).什么是“数据结构”:存储数据的方式;
3).各种不同的数据结构,会影响“增删改查”的性能;
4).常用的数据结构:

    1).栈结构:后进先出

	2).队列结构:先进先出

	3).数组结构:

	4).链表结构:

	5).二叉树:

04.第三章:List的子类:
1).ArrayList:数组实现:
无特有方法
2).LinkedList:链表实现;
1).有几个特有方法,可以模拟栈和队列;
a).public void push(E e) :压栈。
b).public E pop() :弹栈。
2).示例代码:

public class Demo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        //压栈
        list.push("郭德纲");
        list.push("于谦");
        list.push("郭麒麟");
        list.push("柳岩");

        //弹栈
        while (list.size() != 0) {
            System.out.println("弹出一个:" + list.pop());
        }
    }
}

05.第四章:Set集合:
1).特点:
1).无序的;
2).不能存储重复元素;
3).不能通过索引访问元素;
2).子类:
HashSet

    public class Demo {
        public static void main(String[] args) {
            Set<String> set = new HashSet<>();
    
            set.add("赵四");
            set.add("刘能");
            set.add("谢大脚");
            set.add("谢广坤");
            set.add("谢广坤");//add方法返回:false
    
            for(String s : set){
                System.out.println(s);//无序的
            }
        }
    }

3).HashSet存储自定义对象:要求自定义对象必须重写hashCode()和equals()方法
HashSet验证元素唯一性的方式:
在add()方法中,会将参数对象于已存储的所有对象依次进行比较:
1).先比较两个对象的hashCode()是否相同
不同:直接存
相同:再调用equals()比较两个对象
不同:存;
相同:不存
1).自定义对象:

public class Student {
    String name;
    int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public boolean equals(Object o) {
        System.out.println("equals()...");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        System.out.println("hashCode....");
        int c = Objects.hash(name, age);
        return c;
    } }

2).测试类:

public class Demo {
    public static void main(String[] args) {
        Set<Student> stuSet = new HashSet<>();

        stuSet.add(new Student("张思", 17));//add()方法中自动调用对象的hashCode()和equals
        System.out.println("------------------------------");
        stuSet.add(new Student("谢大脚", 16));
        System.out.println("------------------------------");
        stuSet.add(new Student("谢大脚", 16));
        System.out.println("------------------------------");


        //遍历集合
        for (Student stu : stuSet) {
            System.out.println(stu);
        }
    }
}

06.第五章:Collections工具类:
1).java.util.Collections(工具类):它里面包含了很多对Collection集合操作的一些功能性方法。
2).常用方法:
1).public static void shuffle(List<?> list) :打乱集合顺序。

public class Demo {
    public static void main(String[] args) {
        List<String> strList = new ArrayList<>();

        strList.add("张思");
        strList.add("张国荣");
        strList.add("张艺谋");
        strList.add("张国立");

        System.out.println(strList);

        //打乱集合元素的顺序
        Collections.shuffle(strList);
        System.out.println("----------------------------");

        System.out.println(strList);
    }
}

2).public static void sort(List list) :将集合中元素按照默认规则排序。
1).要求:集合中的元素必须实现Comparable接口;
2).示例:
1).Student类:

public class Student  implements Comparable<Student>{
    String name;
    int age;

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

    }

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

    /*
        compareTo的返回值:
        1.负数:当前对象小于参数对象
        2.0 : 当前对象等于参数对象
        3.正数:当前对象大于参数对象
     */
    @Override
    public int compareTo(Student o) {
        //按年龄比:年纪小的排到前
//        return  this.age - o.age;//this - 参数:通常是"升序排序"--从小到大排
        //将年纪大的排前面
        return o.age - this.age;//参数 - this : 通常是"降序排序"--从大到小排
    }
}

3).测试类:

public class Demo {
    public static void main(String[] args) {
        List<Student> stuList = new ArrayList<>();

        stuList.add(new Student("郭德纲", 17));
        stuList.add(new Student("于谦", 18));
        stuList.add(new Student("郭麒麟", 16));

        Collections.sort(stuList);

        System.out.println(stuList);//按年龄排序
    }
}

3).public static void sort(List list,Comparator<? super T> ) :
将集合中元素按照指定规则排序。
1).如果被排序类没有实现Compatable接口,可以使用这种方式:
1).定义一个Student,不需要实现:Comparable接口:

public class Student {
    String name;
    int age;

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

    }

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

2).定义一个“比较器”:

class Zi implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

3).在调用时,同时传递集合,和比较器对象:

public static void main(String[] args) {
    List<Student> stuList = new ArrayList<>();

    stuList.add(new Student("郭德纲", 17));
    stuList.add(new Student("于谦", 18));
    stuList.add(new Student("郭麒麟", 16));
    //传入一个集合,和一个比较器对象,sort()内部会使用比较器去排序,
    //这样就不需要Student有自己的比较的方法。
    Collections.sort(stuList,new Zi());

    System.out.println(stuList);
}

================================================================================================
学习目标总结:
01.能够说出List集合特点
1).有序的;
2).可以存储重复元素;
3).可以通过索引访问元素;
02.能够说出常见的数据结构
1).栈
2).队列
3).数组
4).链表
5).树
03.能够说出数组结构特点
1).查询快;增删慢;
04.能够说出栈结构特点
1).先进后出
05.能够说出队列结构特点
1).先进先出
06.能够说出单向链表结构特点
1).查询慢;增删快;
07.能够说出Set集合的特点
1).无序的;
2).不存储重复元素;
3).不能通过索引访问;
08.能够说出哈希表的特点
1).不存储重复元素;
2).验证元素的唯一性:
1).先判断两个对象的hashCode(),如果相同,再判断equals()
09.使用HashSet集合存储自定义元素
1).自定义元素要重写hashCode()和equals()

    Set<Student> stuSet = new HashSet<>();
	stuSet.add(new Student("郭德纲",17));
	stuSet.add(new Student("郭德纲",17));//添加失败

10.能够使用集合工具类
java.util.Collections(工具类):
1).shuffle():打乱集合元素的顺序;
2).sort(List list):对集合元素排序,要求集合元素必须实现:Comparable接口;
3).sort(List list,Comparator cp):对集合元素排序,集合元素可以不实现Comparable接口,但需要传入一个“比较器对象”。
11.能够使用Comparator比较器进行排序
1).普通类:

class Student{
		...
	}

2).比较器:

class MyComparator implements Comparator<Student>{
			public int compara(Student s1,Student s2){
				return s1.age - s2.age;
			}
		}

3).调用测试:

List<Student> stuList = new ArrayList<>();

		stuList.add(new Student("郭德纲", 17));
		stuList.add(new Student("于谦", 18));
		stuList.add(new Student("郭麒麟", 16));
		//传入一个集合,和一个比较器对象,sort()内部会使用比较器去排序,
		//这样就不需要Student有自己的比较的方法。
		Collections.sort(stuList,new MyComparator());

		System.out.println(stuList);

猜你喜欢

转载自blog.csdn.net/xc965746550/article/details/88804438