Java—集合与泛型

最新推荐文章于 2022-10-24 22:59:20 发布

码小生

最新推荐文章于 2022-10-24 22:59:20 发布

阅读量285

点赞数

分类专栏：华迪Java

本文链接：https://blog.csdn.net/qq_33630838/article/details/79150477

版权

华迪Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Java—集合与泛型

1、数组和集合的区别:

(1)数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值。集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。
(2)数组长度是固定的，不能自动增长。集合的长度的是可变的，可以根据元素的增加而增长。
(3)如果元素个数是固定的推荐用数组，如果元素个数不是固定的推荐用集。

2、Collection的基本功能

用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时，就使用这一接口。

3、Iterator迭代器遍历

迭代器用链表的方式实现了对集合中元素的遍历，常用方法有hasnext()、next()、remove(),对于集合和映射的遍历都可以用Iterator来进行。

4、ArrayList

ArrayList是一个数组实现的列表，由于数据是存入数组中的，所以它的特点也和数组一样，查询很快，但是中间部分的插入和删除很慢，不是线程安全。

功能代码展示：

package com.hwadee;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;

public class Collection1 {

    public static void main(String[] args) {
        testArrayList1();
        testArrayList2();
        testArrayList3();
        testArrayList4();
        testArrayList5();
        testG1();
        testG2();
    }
    public static void testArrayList1() {
        ArrayList arrayList=new ArrayList();
        arrayList.add("学委");
        arrayList.add("班长");
        arrayList.add("体委");
        int size = arrayList.size();
        System.out.println(size);
        boolean contains = arrayList.contains("班长");
        System.out.println(contains);
        String name1 = (String)arrayList.get(0);
        String name2 = (String)arrayList.get(1);
        String name3 = (String)arrayList.get(2);
        System.out.println(name1+"\t"+name2+"\t"+name3);
        System.out.println("---------------------");
    }

    public static void testArrayList2() {
        ArrayList arrayList1=new ArrayList();
        arrayList1.add("大树");
        arrayList1.add(0, "大虫子");
        arrayList1.add("泰坦");
        System.out.println(arrayList1.size());
        String name1 = (String)arrayList1.get(0);
        String name2 = (String)arrayList1.get(1);
        String name3 = (String)arrayList1.get(2);
        System.out.println(name1+"\t"+name2+"\t"+name3);
        System.out.println("----------------------------");
        ArrayList arrayList2=new ArrayList();
        arrayList2.add("猪妹");
        arrayList2.add("厄加特");
        arrayList2.add(1,"狗头");
        arrayList2.add("狗头");
        System.out.println(arrayList2.size());
        String name4 = (String)arrayList2.get(0);
        String name5 = (String)arrayList2.get(1);
        String name6 = (String)arrayList2.get(2);
        System.out.println(name4+"\t"+name5+"\t"+name6);
        System.out.println("-------------------------------");
        arrayList2.addAll(arrayList1);
        System.out.println(arrayList2.size());
        String name7 = (String)arrayList2.get(0);
        String name8 = (String)arrayList2.get(1);
        String name9 = (String)arrayList2.get(2);
        String name10 = (String)arrayList2.get(3);
        String name11 = (String)arrayList2.get(4);
        String name12 = (String)arrayList2.get(5);
        String name13 = (String)arrayList2.get(6);
        System.out.println(name7+"\t"+name8+"\t"+name9+"\t"+name10+"\t"+name11+"\t"+name12+"\t"+name13);
        int indexOf = arrayList2.indexOf("大虫子");
        System.out.println(indexOf);
        int lastIndexOf = arrayList2.lastIndexOf("狗头");
        System.out.println(lastIndexOf);
        System.out.println("-------------------------------");
    }
    public static void testArrayList3() {
        ArrayList arrayList=new ArrayList();
        arrayList.add("李白");
        arrayList.add("杜甫");
        arrayList.add("王维");
        int size = arrayList.size();
        System.out.println(size);

        Iterator iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("---------------------");
    }
    public static void testArrayList4() {
        ArrayList arrayList=new ArrayList();
        arrayList.add("宝马");
        arrayList.add("奔驰");
        arrayList.add("奥迪");
        int size = arrayList.size();
        System.out.println(size);

        Object[] objects = arrayList.toArray();
        for(int i=0;i<objects.length;i++) {
            System.out.println(objects[i]);
        }
        System.out.println("---------------------");
    }
    public static void testArrayList5() {
        ArrayList arrayList=new ArrayList();
        arrayList.add("康熙");
        arrayList.add("雍正");
        arrayList.add("乾隆");
        int size = arrayList.size();
        System.out.println(size);
        for(int i=0;i<arrayList.size();i++) {
            System.out.println(arrayList.get(i));
        }
        boolean isempty = arrayList.isEmpty();
        if(!isempty) {
            arrayList.clear();
            System.out.println(arrayList.size());
        }else {
            System.out.println("本来就是空的");
        }
        System.out.println("---------------------");
    }
    public static void testG1() {
        ArrayList<String> arrayList=new ArrayList<String>();
        arrayList.add("秦皇");
        arrayList.add("汉武");
        arrayList.add("唐宗");
        arrayList.add("宋祖");
        System.out.println(arrayList.size());
        Iterator<String> iterator = arrayList.iterator();
        while(iterator.hasNext()) {
            String next = iterator.next();
            System.out.println(next);
        }
        System.out.println("---------------------");
    }
    public static void testG2() {
        ArrayList<Student> arrayListStudent=new ArrayList<Student>();
        Student s1=new Student(110, "张三", 20);
        Student s2=new Student(112, "李四", 19);
        Student s3=new Student(142, "马倩", 19);
        arrayListStudent.add(s1);
        arrayListStudent.add(s3);
        arrayListStudent.add(s2);
        System.out.println(arrayListStudent.size());
        Iterator<Student> iterator = arrayListStudent.iterator();
        while(iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }
        System.out.println("---------------------");
    }
}
class Student{
    int number;
    String name;
    int age;
    public Student() {

    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    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;
    }
    public Student(int number, String name, int age) {
        super();
        this.number = number;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "学生类 [学号=" + number + ", 姓名=" + name + ", 年龄=" + age + "]";
    }

}

这里写图片描述

5、泛型的使用

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率；没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换只有在运行期才能检查出来，存在安全隐患。泛型最重要应用是在集合框架中保障类型安全。

package com.hwadee;
/*
 * 泛型类的测试
 * 泛型类：把泛型定义在类上
 */
public class TestGenerics1 {

    public static void main(String[] args) {
        ObjectTool<String> obj1=new ObjectTool<String>();
        obj1.setObj("今天没有太阳");
        String string = obj1.getObj();
        System.out.println(string);

        ObjectTool<Integer> obj2=new ObjectTool<Integer>();
        obj2.setObj(9527);
        Integer integer = obj2.getObj();
        System.out.println(integer);

//      obj1.printMessage("无敌多么寂寞");
//      obj2.printMessage(123);
        obj1.printMessage("花儿为什么这样红");
        obj1.printMessage(10000*100000);
        obj1.printMessage(9527);

    }

}
class ObjectTool<T>{
    private T obj;
    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
//  public void printMessage(T t) {
//      System.out.println(t);
//  }
    public void printMessage(String s) {
        System.out.println(s);
    }
    public void printMessage(int number) {
        System.out.println(number);
    }
    public void printMessage(long money) {
        System.out.println(money);
    }
}

这里写图片描述

package com.hwadee;
/*
 * 泛型接口：把泛型定义在接口上
 */
public interface MyInterface {
    public <T> void printMessage(T t);
}

package com.hwadee;

public class MyInterfaceImpl implements MyInterface{
    @Override
    public <T> void printMessage(T t) {
        System.out.println(t);
    }
}

package com.hwadee;

public class Test {

    public static void main(String[] args) {
        MyInterfaceImpl mil=new MyInterfaceImpl();
        mil.printMessage("李白是个大诗人");
        mil.printMessage("李白也是个土绅");
        mil.printMessage(new Long(1000*100000));
    }

}

这里写图片描述

package com.hwadee;
//泛型定义在方法上
public class TestGenerics2 {

    public static void main(String[] args) {
        ObjectW oW=new ObjectW();
        oW.printMessage("天才不过如此");
        oW.printMessage(9526);
        oW.printMessage(new Long(10000*100000));
    }

}
class ObjectW{
    public <T> void printMessage(T t) {
        System.out.println(t);
    }
}

这里写图片描述

package com.hwadee.test4;

import java.util.ArrayList;
import java.util.Collection;

/*
 * 泛型高级(通配符)
 * ?:任意类型，如果没有明确，那么就是Object以及任意的Java类了
 * ? extends E:向下限定，E及其子类
 * ? super E:向上限定，E极其父类
 */
public class GenericDemo {
    public static void main(String[] args) {
        // 泛型如果明确的写的时候，前后必须一致
        Collection<Object> c1 = new ArrayList<Object>();
        //errors
        // Collection<Object> c2 = new ArrayList<Animal>();
        // Collection<Object> c3 = new ArrayList<Dog>();
        // Collection<Object> c4 = new ArrayList<Cat>();

        // ?表示任意的类型都是可以的
        Collection<?> c5 = new ArrayList<Object>();
        Collection<?> c6 = new ArrayList<Animal>();
        Collection<?> c7 = new ArrayList<Dog>();
        Collection<?> c8 = new ArrayList<Cat>();

        // ? extends E:向下限定，E及其子类
        //errors
        // Collection<? extends Animal> c9 = new ArrayList<Object>();
        Collection<? extends Animal> c10 = new ArrayList<Animal>();
        Collection<? extends Animal> c11 = new ArrayList<Dog>();
        Collection<? extends Animal> c12 = new ArrayList<Cat>();

        // ? super E:向上限定，E极其父类
        Collection<? super Animal> c13 = new ArrayList<Object>();
        Collection<? super Animal> c14 = new ArrayList<Animal>();
        //errors
        // Collection<? super Animal> c15 = new ArrayList<Dog>();
        // Collection<? super Animal> c16 = new ArrayList<Cat>();
    }
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}

码小生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java—集合与泛型

Java—集合与泛型1、数组和集合的区别:(1)数组既可以存储基本数据类型，又可以存储引用数据类型，基本数据类型存储的是值，引用数据类型存储的是地址值。集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型，但是在存储的时候会自动装箱变成对象。(2)数组长度是固定的，不能自动增长。集合的长度的是可变的，可以根据元素的增加而增长。(3)如果元素个数是固定的推荐用数组，如果元素个数不
复制链接

扫一扫