JAVA进阶知识点总结 3-List类、Set类、数据结构、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 list = new ArrayList<>();
System.out.println(list.get(0));//抛异常
System.out.println(list.remove(0));//抛异常

03.第二章：数据结构：

1).各种不同的集合类，采用了不同的“存储数据的方式”，这种存储数据的方式就叫：数据结构。
2).什么是“数据结构”：存储数据的方式；
3).各种不同的数据结构，会影响“增删改查”的性能；
常用的数据结构：

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 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);