怎么取集合得索引值集合可以索引吗

转载

mob64ca1401b651 2024-07-29 18:25:27

文章标签 怎么取集合得索引值 java System Java 泛型 文章分类 数据仓库大数据

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

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

public class ColectionDemo {
    public static void main(String[] args) {
        //有序可重复有索引
        Collection list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("Mybatis");
        list.add(23);
        list.add(23);
        list.add(false);
        list.add(false);
        System.out.println(list);
        //无序不重复 无索引
        Collection list1 = new HashSet() ;
        list1.add("Java");
        list1.add("Java");
        list1.add("Mybatis");
        list1.add(23);
        list1.add(23);
        list1.add(false);
        list1.add(false);
        System.out.println(list1);

        //有序不重复 无索引
        Collection list2 = new TreeSet() ;
        list2.add("Java1");
        list2.add("Java");
        list2.add("Java");
        list2.add("Mybatis");
        list2.add("1");
        System.out.println(list2);

        //支持泛型
        Collection<String> list3 = new ArrayList<>() ;
        list3.add("Java1");
        list3.add("Java");
        list3.add("Java");
//        list3.add(1);
        System.out.println(list2);

    }
}

Collection常用API

怎么取集合得索引值集合可以索引吗_System

public class ColectionDemo {
    public static void main(String[] args) {
        Collection list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("Java");
        System.out.println(list);
//        list.clear();
        System.out.println(list);
        System.out.println("删除成功返回true，默认删除第一个"+list.remove("Java"));
        System.out.println(list);
        System.out.println(list.isEmpty());
        System.out.println(list.size());
        System.out.println(list.toArray());
    }
}

Collection迭代器

public class ColectionDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("Java1");
        c.add("Java3");
        c.add("Java3");
        Iterator<String> i = c.iterator(); //创建一个迭代器对象，泛类型与数组保持一致,默认起始位置为0
//        System.out.println("判断是否还有元素"+i.hasNext());
//        System.out.println("取出第一个数"+i.next());
//        System.out.println("取出第二个数"+i.next());
//        System.out.println("取出第三个数"+i.next());
//        System.out.println("数量不足，会越越界报错"+i.next());
        while (i.hasNext()){
            System.out.println(i.next());
        }

    }
}

Colection之foreach

1、增强for可以遍历哪些容器? ●既可以遍历集合也可以遍历数组。
2、增强for的关键是记住它的遍历格式
   for(元素数据类型 变量名:数组或者Collection集合) {
            //在此处使用变量即可，该变量就是元素
    }

public class ColectionDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("Java1");
        c.add("Java3");
        c.add("Java3");
        for (String s : c) {
            System.out.println("s是变量名" + s);
        }
        double[] d = {1.1,2.1,3.1};
        for (double v : d) {
            System.out.println("v是变量名" + v);
        }
    }
}


public class ColectionDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("Java1");
        c.add("Java3");
        c.add("Java3");
        // forEach几种方法
        c.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        c.forEach((String s)->System.out.println(s));
        c.forEach(s->System.out.println(s));
        c.forEach(System.out::println);//最终简写，实际效果一样
    }
}

List,包含ArrayList，LinkedList实现类

public class ColectionDemo {
    public static void main(String[] args) {

        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.add("MySQL");
        // 2.在某个索引位置插入元素。
        list.add( 2,"HTML");
        System.out.println(list);
        // 3.根据索引删除元素,返回被删除元素
        System.out.println(list.remove(2));
        System.out.println(list);
        // 4. 根据索引获取元素:public E get(int index): 返回集合中指定位置的元素。
        System.out.println(list.get(2));
        // 5.修改索引位置处的元素: public E set(int index, E element)
        //返回修改前的数据
        System.out.println(list.set(1,"高斯林"));
        System.out.println(list);


    }
}

public class ColectionDemo {
    public static void main(String[] args) {
        //栈，先进后出
        LinkedList<String> stack = new LinkedList<>();
        stack.addFirst("第一颗子弹");
        stack.addFirst("第二颗子弹");
        stack.addFirst("第三颗子弹");
        stack.addFirst("第四颗子弹");
        System.out.println(stack.removeFirst());
        System.out.println(stack.removeFirst());
        System.out.println(stack.removeFirst());
        System.out.println(stack);

        //队列，先进先出
        LinkedList<String> queue = new LinkedList<>();
        queue.addLast("1号");
        queue.addLast("2号");
        queue.addLast("3号");
        queue.addLast("4号");
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
    }
}

自定义泛型

泛型类
作用：强制类下的方法只能使用同一种引用类型
public class FanXing <E>{
    public void add(E e){
    }
    public void remove(E e){
        
    }
}

public class Test {
    public static void main(String[] args) {
        FanXing<String> f = new FanXing<>();
        f.add("a"); 
        f.remove("a");
    }
}
======================================================================
泛型方法
作用：方法可以接收任意类型的数据，使得更加有通用型

public class Test {
    public static void main(String[] args) {
        Integer[] i = {1,2,3,4,5};
        prinaArray(i);
    }
    /*
    定义一个可以传任意类型的数组
     */
    public static <T> void prinaArray(T[] arry) {
        if(arry != null){
            StringBuilder h = new StringBuilder("[");
            for (int i = 0; i < arry.length; i++) {
                h.append(i == arry.length -1 ? arry[i]: arry[i] + ",");
            }
            h.append("]");
            System.out.println(h);
        }else {
            System.out.println(Arrays.toString(arry));
        }
    }
}
==================================================
泛型接口
作用:泛型接口可以让实现类选择当前功能需要操作的数据类型
//定义一个泛型接口
public interface FangXing <E>{
    void add(E e);
    void delete(int id);
    void update(E e);
    E queryId(int id);
}

//定义一个类型只可以接受Teacher

public class TeacherData implements FangXing<Teacher>{
    @Override
    public void add(Teacher teacher) {
        System.out.println("加了一个老师信息");
    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void update(Teacher teacher) {

    }

    @Override
    public Teacher queryId(int id) {
        return null;
    }
}

//定义一个Teacher类
public class Teacher{
}

//使用
public class Test {
    public static void main(String[] args) {
        Teacher t = new Teacher();
        TeacherData TD = new TeacherData();
        TD.add(t);
    }
}

使用泛型

泛型的上下限:
<? extends Car>  >>?必须是Car或者其子类泛型：上限(常用)
<? super Car>    >>?必须是Car或者其父类泛型：下限

import java.util.ArrayList;

public class UseFangXing {
    public static void main(String[] args) {
        ArrayList<Benchi> ben = new ArrayList<>();
        ArrayList<Baoma> bao = new ArrayList<>();
        ArrayList<Dog> dog = new ArrayList<>();
        ben.add(new Benchi());
        bao.add(new Baoma());
        dog.add(new Dog());
        go(ben);
        go(bao);
        // go(dog); 无法添加
    }
    public static void go(ArrayList<? extends Car> allCar){
        System.out.println("所有车都可以参加" + allCar.toString());
    }
}

class Benchi extends Car{
    private String name = "奔驰";
    @Override
    public String toString() {
        return "Benchi{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Baoma extends Car{
    private String name = "宝马";
    @Override
    public String toString() {
        return "Baoma{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Dog{
    private String name = "狗";
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Car {}

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

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

基本使用

public class Test {
    public static void main(String[] args) {
        // 无序
        Set<String> sets = new HashSet<>();
        sets.add("html");
        sets.add("java");
        sets.add("java");
        sets.add("Mysql");
        System.out.println(sets);
        // 有序
        Set<String> sets1 = new LinkedHashSet<>();
        sets1.add("html");
        sets1.add("java");
        sets1.add("java");
        sets1.add("Mysql");
        System.out.println(sets1);
        // 排序
        Set<String> sets2 = new TreeSet<>();
        sets2.add("html");
        sets2.add("java");
        sets2.add("java");
        sets2.add("Mysql");
        System.out.println(sets2);
        System.out.println(sets.hashCode());// object提供了hashCode,代表每个对象都有一个hash值，且同一个对象值是保持不变的

    }
}

hsahcode重写

public class Test {
    public static void main(String[] args) {
        //底层原理是hash+数组+链表+红黑树，先计算对象的hash值后取mod，然后得到的索引插入数组，                
        //如果为null直接插入，不为null再用equals去判断数据有没有重复，有重复就不插入，不重复就 
        //放入该数据，原先数据根据链表方式接入到新的数据,
        //因此自定义的类使用set集合，需要重写hashcode方法，只要类的值一样，
        //hash值就一样，则不重复添加到集合里面
        Set<Student> sets = new HashSet<>();
        sets.add(new Student("小红",19,"男"));
        sets.add(new Student("小红",19,"男"));
        sets.add(new Student("小A",19,"男"));
        System.out.println(sets);
    }
}


class Student {
    private String name;
    private Integer age;
    private String sex;

    public Student() {
    }

    public Student(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name) && Objects.equals(age, student.age) && Objects.equals(sex, student.sex);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, sex);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

Treeset自定义排序规则

package com.ruqi.xiushifu.demoset;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //自定义类的排序规则，使用set自带的Comparator方法,也可以在Student类中自定义
//        Set<Student> Students = new TreeSet<>(new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
                return o1.getAge() - o2.getAge(); //表示按年龄升序，如果相等去重
//                return o1.getAge() - o2.getAge() >= 0 ? 1 : -1 ; //表示按年龄升序，不去重
//            }
//        });
        Set<Student> Students = new TreeSet<>((o1, o2) -> o1.getAge() - o2.getAge() >= 0 ? 1 : -1); //简写     
        Students.add(new Student("小A",11,"男",12.11));
        Students.add(new Student("小B",11,"男",12.01));
        Students.add(new Student("小C",12,"男",12.71));
        Students.add(new Student("小D",14,"男",12.01));
        System.out.println(Students);
    }
}

class Student implements Comparable<Student>{
    private String name;
    private Integer age;
    private String sex;
    private double height;

    public Student() {
    }

    public Student(String name, Integer age, String sex , double height) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

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

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。