• Java之Collention集合

    1、集合的代表是?
    ●Collection接口 。
    2、Collection集合分 了哪2大常用的集合体系?
    ●List系列集合: 添加的元素是有序、可重复、有索引。
    ●Set系列集合:添加的元素是无序、不重复、无索引。
    3、如何约定集合存储数据的类型，需要注意什么?
    ●集合支持泛型。
    ●集合和泛型不支持基本类型，只支持引用数据类型。

    ●集合不支持使用索引查找数据

    1. public class ColectionDemo {
    2.     public static void main(String[] args) {
    3.         //有序可重复有索引
    4.         Collection list = new ArrayList();
    5.         list.add("Java");
    6.         list.add("Java");
    7.         list.add("Mybatis");
    8.         list.add(23);
    9.         list.add(23);
    10.         list.add(false);
    11.         list.add(false);
    12.         System.out.println(list);
    13.         //无序不重复 无索引
    14.         Collection list1 = new HashSet() ;
    15.         list1.add("Java");
    16.         list1.add("Java");
    17.         list1.add("Mybatis");
    18.         list1.add(23);
    19.         list1.add(23);
    20.         list1.add(false);
    21.         list1.add(false);
    22.         System.out.println(list1);
    23.  
    24.         //有序不重复 无索引
    25.         Collection list2 = new TreeSet() ;
    26.         list2.add("Java1");
    27.         list2.add("Java");
    28.         list2.add("Java");
    29.         list2.add("Mybatis");
    30.         list2.add("1");
    31.         System.out.println(list2);
    32.  
    33.         //支持泛型
    34.         Collection list3 = new ArrayList<>() ;
    35.         list3.add("Java1");
    36.         list3.add("Java");
    37.         list3.add("Java");
    38. //        list3.add(1);
    39.         System.out.println(list2);
    40.  
    41.     }
    42. }

     Collection常用API

    1. public class ColectionDemo {
    2.     public static void main(String[] args) {
    3.         Collection list = new ArrayList();
    4.         list.add("Java");
    5.         list.add("Java");
    6.         list.add("Java");
    7.         System.out.println(list);
    8. //        list.clear();
    9.         System.out.println(list);
    10.         System.out.println("删除成功返回true，默认删除第一个"+list.remove("Java"));
    11.         System.out.println(list);
    12.         System.out.println(list.isEmpty());
    13.         System.out.println(list.size());
    14.         System.out.println(list.toArray());
    15.     }
    16. }

    Collection迭代器

    1. public class ColectionDemo {
    2.     public static void main(String[] args) {
    3.         Collection c = new ArrayList<>();
    4.         c.add("Java1");
    5.         c.add("Java3");
    6.         c.add("Java3");
    7.         Iterator i = c.iterator(); //创建一个迭代器对象，泛类型与数组保持一致,默认起始位置为0
    8. //        System.out.println("判断是否还有元素"+i.hasNext());
    9. //        System.out.println("取出第一个数"+i.next());
    10. //        System.out.println("取出第二个数"+i.next());
    11. //        System.out.println("取出第三个数"+i.next());
    12. //        System.out.println("数量不足，会越越界报错"+i.next());
    13.         while (i.hasNext()){
    14.             System.out.println(i.next());
    15.         }
    16.  
    17.     }
    18. }
    Colection之foreach
    1. 1、增强for可以遍历哪些容器? ●既可以遍历集合也可以遍历数组。
    2. 2、增强for的关键是记住它的遍历格式
    3.    for(元素数据类型 变量名:数组或者Collection集合) {
    4.             //在此处使用变量即可，该变量就是元素
    5.     }
    6.  
    7. public class ColectionDemo {
    8.     public static void main(String[] args) {
    9.         Collection c = new ArrayList<>();
    10.         c.add("Java1");
    11.         c.add("Java3");
    12.         c.add("Java3");
    13.         for (String s : c) {
    14.             System.out.println("s是变量名" + s);
    15.         }
    16.         double[] d = {1.1,2.1,3.1};
    17.         for (double v : d) {
    18.             System.out.println("v是变量名" + v);
    19.         }
    20.     }
    21. }
    22.  
    23.  
    24. public class ColectionDemo {
    25.     public static void main(String[] args) {
    26.         Collection c = new ArrayList<>();
    27.         c.add("Java1");
    28.         c.add("Java3");
    29.         c.add("Java3");
    30.         // forEach几种方法
    31.         c.forEach(new Consumer() {
    32.             @Override
    33.             public void accept(String s) {
    34.                 System.out.println(s);
    35.             }
    36.         });
    37.  
    38.         c.forEach((String s)->System.out.println(s));
    39.         c.forEach(s->System.out.println(s));
    40.         c.forEach(System.out::println);//最终简写，实际效果一样
    41.     }
    42. }

    List,包含ArrayList，LinkedList实现类

    1. public class ColectionDemo {
    2.     public static void main(String[] args) {
    3.  
    4.         List list = new ArrayList<>();
    5.         list.add("Java");
    6.         list.add("Java");
    7.         list.add("MySQL");
    8.         list.add("MySQL");
    9.         // 2.在某个索引位置插入元素。
    10.         list.add( 2,"HTML");
    11.         System.out.println(list);
    12.         // 3.根据索引删除元素,返回被删除元素
    13.         System.out.println(list.remove(2));
    14.         System.out.println(list);
    15.         // 4. 根据索引获取元素:public E get(int index): 返回集合中指定位置的元素。
    16.         System.out.println(list.get(2));
    17.         // 5.修改索引位置处的元素: public E set(int index, E element)
    18.         //返回修改前的数据
    19.         System.out.println(list.set(1,"高斯林"));
    20.         System.out.println(list);
    21.  
    22.  
    23.     }
    24. }
    25.  
    26. public class ColectionDemo {
    27.     public static void main(String[] args) {
    28.         //栈，先进后出
    29.         LinkedList stack = new LinkedList<>();
    30.         stack.addFirst("第一颗子弹");
    31.         stack.addFirst("第二颗子弹");
    32.         stack.addFirst("第三颗子弹");
    33.         stack.addFirst("第四颗子弹");
    34.         System.out.println(stack.removeFirst());
    35.         System.out.println(stack.removeFirst());
    36.         System.out.println(stack.removeFirst());
    37.         System.out.println(stack);
    38.  
    39.         //队列，先进先出
    40.         LinkedList queue = new LinkedList<>();
    41.         queue.addLast("1号");
    42.         queue.addLast("2号");
    43.         queue.addLast("3号");
    44.         queue.addLast("4号");
    45.         System.out.println(queue.removeFirst());
    46.         System.out.println(queue.removeFirst());
    47.         System.out.println(queue);
    48.     }
    49. }

    自定义泛型 

    1. 泛型类
    2. 作用：强制类下的方法只能使用同一种引用类型
    3. public class FanXing {
    4.     public void add(E e){
    5.     }
    6.     public void remove(E e){
    7.         
    8.     }
    9. }
    10.  
    11. public class Test {
    12.     public static void main(String[] args) {
    13.         FanXing f = new FanXing<>();
    14.         f.add("a"); 
    15.         f.remove("a");
    16.     }
    17. }
    18. ======================================================================
    19. 泛型方法
    20. 作用：方法可以接收任意类型的数据，使得更加有通用型
    21.  
    22. public class Test {
    23.     public static void main(String[] args) {
    24.         Integer[] i = {1,2,3,4,5};
    25.         prinaArray(i);
    26.     }
    27.     /*
    28.     定义一个可以传任意类型的数组
    29.      */
    30.     public static  void prinaArray(T[] arry) {
    31.         if(arry != null){
    32.             StringBuilder h = new StringBuilder("[");
    33.             for (int i = 0; i < arry.length; i++) {
    34.                 h.append(i == arry.length -1 ? arry[i]: arry[i] + ",");
    35.             }
    36.             h.append("]");
    37.             System.out.println(h);
    38.         }else {
    39.             System.out.println(Arrays.toString(arry));
    40.         }
    41.     }
    42. }
    43. ==================================================
    44. 泛型接口
    45. 作用:泛型接口可以让实现类选择当前功能需要操作的数据类型
    46. //定义一个泛型接口
    47. public interface FangXing {
    48.     void add(E e);
    49.     void delete(int id);
    50.     void update(E e);
    51.     E queryId(int id);
    52. }
    53.  
    54. //定义一个类型只可以接受Teacher
    55.  
    56. public class TeacherData implements FangXing{
    57.     @Override
    58.     public void add(Teacher teacher) {
    59.         System.out.println("加了一个老师信息");
    60.     }
    61.  
    62.     @Override
    63.     public void delete(int id) {
    64.  
    65.     }
    66.  
    67.     @Override
    68.     public void update(Teacher teacher) {
    69.  
    70.     }
    71.  
    72.     @Override
    73.     public Teacher queryId(int id) {
    74.         return null;
    75.     }
    76. }
    77.  
    78. //定义一个Teacher类
    79. public class Teacher{
    80. }
    81.  
    82. //使用
    83. public class Test {
    84.     public static void main(String[] args) {
    85.         Teacher t = new Teacher();
    86.         TeacherData TD = new TeacherData();
    87.         TD.add(t);
    88.     }
    89. }
    90.  
    91.

    使用泛型

    1. 泛型的上下限:
    2. extends Car>  >>?必须是Car或者其子类泛型：上限(常用)
    3. super Car>    >>?必须是Car或者其父类泛型：下限
    4.  
    5. import java.util.ArrayList;
    6.  
    7. public class UseFangXing {
    8.     public static void main(String[] args) {
    9.         ArrayList ben = new ArrayList<>();
    10.         ArrayList bao = new ArrayList<>();
    11.         ArrayList dog = new ArrayList<>();
    12.         ben.add(new Benchi());
    13.         bao.add(new Baoma());
    14.         dog.add(new Dog());
    15.         go(ben);
    16.         go(bao);
    17.         // go(dog); 无法添加
    18.     }
    19.     public static void go(ArrayList allCar){
    20.         System.out.println("所有车都可以参加" + allCar.toString());
    21.     }
    22. }
    23.  
    24. class Benchi extends Car{
    25.     private String name = "奔驰";
    26.     @Override
    27.     public String toString() {
    28.         return "Benchi{" +
    29.                 "name='" + name + '\'' +
    30.                 '}';
    31.     }
    32. }
    33. class Baoma extends Car{
    34.     private String name = "宝马";
    35.     @Override
    36.     public String toString() {
    37.         return "Baoma{" +
    38.                 "name='" + name + '\'' +
    39.                 '}';
    40.     }
    41. }
    42. class Dog{
    43.     private String name = "狗";
    44.     @Override
    45.     public String toString() {
    46.         return "Dog{" +
    47.                 "name='" + name + '\'' +
    48.                 '}';
    49.     }
    50. }
    51. class Car {}

     Set系列集合特点
    ●无序:存取顺序不-致
    ●不重复:可以去除重复
    ●无索引: 没有带索引的方法,所以不能使用普通for循环遍历，也不能通过索引来获取元素。
     

    Set集合实现类特点
    ●HashSet: 无序、不重复、无索引。
    ●LinkedHashSet: 有序、不重复、无索引。
    ●TreeSet: 排序、不重复、无索引。
     

    基本使用

    1.  
    2. public class Test {
    3.     public static void main(String[] args) {
    4.         // 无序
    5.         Set sets = new HashSet<>();
    6.         sets.add("html");
    7.         sets.add("java");
    8.         sets.add("java");
    9.         sets.add("Mysql");
    10.         System.out.println(sets);
    11.         // 有序
    12.         Set sets1 = new LinkedHashSet<>();
    13.         sets1.add("html");
    14.         sets1.add("java");
    15.         sets1.add("java");
    16.         sets1.add("Mysql");
    17.         System.out.println(sets1);
    18.         // 排序
    19.         Set sets2 = new TreeSet<>();
    20.         sets2.add("html");
    21.         sets2.add("java");
    22.         sets2.add("java");
    23.         sets2.add("Mysql");
    24.         System.out.println(sets2);
    25.         System.out.println(sets.hashCode());// object提供了hashCode,代表每个对象都有一个hash值，且同一个对象值是保持不变的
    26.  
    27.     }
    28. }

     hsahcode重写

    1.  
    2. public class Test {
    3.     public static void main(String[] args) {
    4.         //底层原理是hash+数组+链表+红黑树，先计算对象的hash值后取mod，然后得到的索引插入数组，                
    5.         //如果为null直接插入，不为null再用equals去判断数据有没有重复，有重复就不插入，不重复就 
    6.         //放入该数据，原先数据根据链表方式接入到新的数据,
    7.         //因此自定义的类使用set集合，需要重写hashcode方法，只要类的值一样，
    8.         //hash值就一样，则不重复添加到集合里面
    9.         Set sets = new HashSet<>();
    10.         sets.add(new Student("小红",19,"男"));
    11.         sets.add(new Student("小红",19,"男"));
    12.         sets.add(new Student("小A",19,"男"));
    13.         System.out.println(sets);
    14.     }
    15. }
    16.  
    17.  
    18. class Student {
    19.     private String name;
    20.     private Integer age;
    21.     private String sex;
    22.  
    23.     public Student() {
    24.     }
    25.  
    26.     public Student(String name, Integer age, String sex) {
    27.         this.name = name;
    28.         this.age = age;
    29.         this.sex = sex;
    30.     }
    31.  
    32.     @Override
    33.     public boolean equals(Object o) {
    34.         if (this == o) return true;
    35.         if (o == null || getClass() != o.getClass()) return false;
    36.         Student student = (Student) o;
    37.         return Objects.equals(name, student.name) && Objects.equals(age, student.age) && Objects.equals(sex, student.sex);
    38.     }
    39.  
    40.     @Override
    41.     public int hashCode() {
    42.         return Objects.hash(name, age, sex);
    43.     }
    44.  
    45.     public String getName() {
    46.         return name;
    47.     }
    48.  
    49.     public void setName(String name) {
    50.         this.name = name;
    51.     }
    52.  
    53.     public Integer getAge() {
    54.         return age;
    55.     }
    56.  
    57.     public void setAge(Integer age) {
    58.         this.age = age;
    59.     }
    60.  
    61.     public String getSex() {
    62.         return sex;
    63.     }
    64.  
    65.     public void setSex(String sex) {
    66.         this.sex = sex;
    67.     }
    68.  
    69.     @Override
    70.     public String toString() {
    71.         return "Student{" +
    72.                 "name='" + name + '\'' +
    73.                 ", age=" + age +
    74.                 ", sex='" + sex + '\'' +
    75.                 '}';
    76.     }
    77. }

    Treeset自定义排序规则

    1. package com.ruqi.xiushifu.demoset;
    2.  
    3. import java.util.*;
    4.  
    5. public class Test {
    6.     public static void main(String[] args) {
    7.         //自定义类的排序规则，使用set自带的Comparator方法,也可以在Student类中自定义
    8. //        Set Students = new TreeSet<>(new Comparator() {
    9. //            @Override
    10. //            public int compare(Student o1, Student o2) {
    11.                 return o1.getAge() - o2.getAge(); //表示按年龄升序，如果相等去重
    12. //                return o1.getAge() - o2.getAge() >= 0 ? 1 : -1 ; //表示按年龄升序，不去重
    13. //            }
    14. //        });
    15.         Set Students = new TreeSet<>((o1, o2) -> o1.getAge() - o2.getAge() >= 0 ? 1 : -1); //简写     
    16.         Students.add(new Student("小A",11,"男",12.11));
    17.         Students.add(new Student("小B",11,"男",12.01));
    18.         Students.add(new Student("小C",12,"男",12.71));
    19.         Students.add(new Student("小D",14,"男",12.01));
    20.         System.out.println(Students);
    21.     }
    22. }
    23.  
    24. class Student implements Comparable{
    25.     private String name;
    26.     private Integer age;
    27.     private String sex;
    28.     private double height;
    29.  
    30.     public Student() {
    31.     }
    32.  
    33.     public Student(String name, Integer age, String sex , double height) {
    34.         this.name = name;
    35.         this.age = age;
    36.         this.sex = sex;
    37.         this.height = height;
    38.     }
    39.  
    40.     public double getHeight() {
    41.         return height;
    42.     }
    43.  
    44.     public void setHeight(double height) {
    45.         this.height = height;
    46.     }
    47.  
    48.     public String getName() {
    49.         return name;
    50.     }
    51.  
    52.     public void setName(String name) {
    53.         this.name = name;
    54.     }
    55.  
    56.     public Integer getAge() {
    57.         return age;
    58.     }
    59.  
    60.     public void setAge(Integer age) {
    61.         this.age = age;
    62.     }
    63.  
    64.     public String getSex() {
    65.         return sex;
    66.     }
    67.  
    68.     public void setSex(String sex) {
    69.         this.sex = sex;
    70.     }
    71.  
    72.     @Override
    73.     public String toString() {
    74.         return "Student{" +
    75.                 "name='" + name + '\'' +
    76.                 ", age=" + age +
    77.                 ", sex='" + sex + '\'' +
    78.                 ", height=" + height +
    79.                 '}';
    80.     }
    81.  
    82.     @Override
    83.     public int compareTo(Student o) {
    84.         return this.age - o.age;
    85.     }
    86. }
    87.

  • 相关阅读:
    代码随想录day动态规划回文子串
    MySQL-(3)
    面向临床需求的CT图像降噪综述
    S1_servlet与数据库连接、filter过滤器、分页 实操的叙述
    玩转Android10源码开发定制(五)之源码目录说明及模块源码路径定位
    Neo4j离线环境搭建与基于python中py2neo的简单操作
    1235. 规划兼职工作（难度：困难）
    掌握基本排序算法：冒泡、选择、插入和快速排序
    人大女王大学金融硕士项目——披星戴月走过的路，一定可以繁花满地
    bindParam() 和 bindValue() 的区别
  • 原文地址：https://blog.csdn.net/qq_34577961/article/details/127539325