Java=Collection，泛型，数据结构

最新推荐文章于 2023-11-30 17:43:33 发布

hnbyboy

最新推荐文章于 2023-11-30 17:43:33 发布

阅读量957

点赞数 1

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/appandroid/article/details/104781140

版权

JAVA 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

前言：

1.Collection(所有集合的根接口)
    2.根接口中共性方法
    3.迭代器(用于遍历集合)
    4.泛型
    5.数据结构

1.Collection集合

集合的介绍&集合和数组的区别

什么是集合?
    集合就是Java用来保存数据的容器.我们学过哪些容器??
    数组,ArrayList
    数组定义: 数据类型[] 变量名 = new 数据类型[数组的长度];
   集合定义: ArrayList<数据类型> 变量名 = new ArrayList<数据类型>();
数组和集合的区别在吗?
    i.数组长度是固定的,集合的长度是可变的
    ii.数组中元素类型可以是基本类型,也可以是引用类型
       但是集合中元素类型必须只能是引用类型,如果想保持基本类型,要写该基本类型对应的包装类
       比如:
           ArrayList<int> arr = new ArrayList<int>();//报错!!
           ArrayList<Integer> arr = new ArrayList<Integer>();//对的

2.Collection的子类

List,Set接口子类

3.Collection中的通用方法

增:增加
   public boolean add(E e);  添加元素,返回值表示是否添加成功!
删:删除
   public boolean remove(E e); 删除元素,返回值表示是否删除成功!
改:修改
   无!
查:获取
   无!
其他:
	public boolean contains(Object obj); 判断集合中是否包含某个元素
    public void clear(); 清空集合(把集合的元素全部删除,不是把集合置为null)
    public boolean isEmpty(); 判断集合是否为空(是指集合中是否没有元素,并不是值集合是否为null)
	public int size(); 返回集合中元素的个数
    public Object[] toArray(); 将集合转成数组  
        
public class TestCollection {
    public static void main(String[] args) {
        //1.创建一个ArrayList
        Collection<String> cc = new ArrayList<String>(); //多态
        //2.测试方法
        //添加
        cc.add("java1");
        cc.add("java2");
        cc.add("java3");
        cc.add("java4");
        System.out.println(cc);//不会打印出来地址,而是打印出来集合中的元素内容
        //删除
        boolean b = cc.remove("java4");
        System.out.println("是否删除成功:" + b);
        System.out.println(cc);
        //其他方法
        //判断是否包含
        boolean b1 = cc.contains("java2");
        System.out.println("是否包含:"+b1);
        //清空集合
        cc.clear();
        System.out.println(cc);
        //判断是否集合没有元素
        boolean b2 = cc.isEmpty();
        System.out.println("集合是否为空集合:"+b2);
        //获取集合的长度
        int size = cc.size();
        System.out.println("集合中元素的个数:"+size);
        //将集合转成数组
        Object[] objects = cc.toArray();
        System.out.println(objects[0]);
        System.out.println(objects[1]);
        System.out.println(objects[2]);
    }
}

二 Iterator 迭代器

1.集合迭代器的介绍和使用

a.迭代器(iterator):
	用于遍历集合的对象(集合有无索引,均可使用迭代器来遍历,迭代器遍历集合时是不需要索引的!!!)
b.如何使用迭代器?
   i.获取要遍历的集合的迭代器对象
   ii.调用迭代器对象.hasNext();
   iii.调用迭代器对象.next();

public class TestIterator {
    public static void main(String[] args) {
        //1.创建一个集合
        Collection<String> cc = new ArrayList<String>();
        //添加
        cc.add("java");
        cc.add("php");
        cc.add("python");
        cc.add("c++");
        cc.add("c");
        cc.add("c#");
        cc.add("Objective-C");
        //使用迭代器
//        i.获取要遍历的集合的迭代器对象
        Iterator<String> it = cc.iterator();
//        ii.调用迭代器对象.hasNext();
//        iii.调用迭代器对象.next();
        while (it.hasNext()){
            String ss = it.next();
            System.out.println(ss);
        }
    }
}

迭代器的注意事项(2个异常):

a.NoSuchElementException: 没有此元素异常
    出现原因: 迭代器的hasNext返回false,再调用next方法,就会出现此异常
b.ConcurrentModificationException: 并发修改异常
    出现原因: Java的迭代器规定,使用迭代器的过程中,不能向集合中增删元素(不能影响集合的长度)
        	否则就会抛出并发修改异常
结论:
	a.使用迭代器时,必须先使用hasNext方法判断,且判断结果为true,才能调用next方法
    b.使用迭代器时,我们应该尽量只做遍历(绝对不允许直接向集合中增删元素)

迭代器的原理(画图)

迭代器的底层使用了"指针原理"

3增强for循环

a.什么是增强for循环
    实际上是一种简便格式(语法糖),实际上是迭代器的语法糖
    
b.增强for循环的用法:
	for(数据类型 变量名:集合/数组){
        System.out.println(变量名);
    }

public class TestForeach {
    public static void main(String[] args) {
        //1.增强for循环,可以快速遍历集合/数组
        //a.数组
        int[] arr = {10,20,30,40,50,60,70};

        for(int num : arr){
            System.out.println(num);
        }
        //b.集合
        ArrayList<String> arr2 = new ArrayList<String>();
        arr2.add("java1");
        arr2.add("java2");
        arr2.add("java3");
        arr2.add("java4");
        arr2.add("java5");
        arr2.add("java6");

        for(String s : arr2){
            System.out.println(s);
        }
    }
}
c.增强for循环底层使用的就是迭代器
    怎么证明呢??
    	a.看源码(目前你是看不懂)
    	b.如果在使用增强for的过程中向集合中添加或者删除元素会怎么样??
    		和使用迭代器时一样也会抛出 ConcurrentModificationException
    注意:和使用迭代器一样,增强for就是用于单纯的遍历集合,不要在遍历的过程中增删元素!!

三，泛型

1.什么是泛型

泛型是JDK1.5的新特性
比如:
	在JDK1.5之前,创建集合: ArrayList arr = new ArrayList(),集合中可以保存任意的对象
    在JDK1.5时候,创建集合: ArrayList<具体的引用类型> arr = new ArrayList<具体的引用类型>();

什么是泛型:
	是一种不确定的类型,程序员使用时再确定下来
泛型的格式:
	<E>,<P>,<MVP> 
    <K,V>

2.泛型的好处

public class TestGeneric {
    public static void main(String[] args) {
        method2();
    }
    //不使用泛型
    public static void method1(){
        //1.创建集合,但是不用泛型
        ArrayList arr = new ArrayList();
        //问题: 没写泛型,集合可以保存什么类型?? Object类型
        arr.add("java");
        arr.add(10);
        arr.add(3.14);
        arr.add(true);
        arr.add('A');
        //2.取出
        for(Object s :arr){
            String ss = (String)s;
            System.out.println("ss的长度是:"+ss.length());
        }
        //不使用泛型,就必须用到向下转型,可能转型的过程中还会引发ClassCastException
        //添加元素一时爽,取出元素火葬场
    }

    //使用泛型
    public static void method2(){
        //1.创建集合,并且使用泛型
        ArrayList<String> arr = new ArrayList<String>();
        //2.添加
        arr.add("java");
        arr.add("10");
        arr.add("3.14");
        arr.add("true");
        arr.add("A");
        //3.取出
        for(String s:arr){
            //a.避免向下转型的麻烦
            //b.也避免了类型转换异常
            System.out.println(s+"的长度是:"+s.length());
        }
    }
}

总结泛型的好处:
	a.避免了强转(向下转型)的麻烦
    b.将运行时期的ClassCastException，转移到了编译时期变成了编译失败。 
    c.总之: JDK1.5之后,Java强烈推荐(必须)使用泛型!

3.泛型的定义和使用

泛型可以定义在类上,方法上,接口上!

泛型类

泛型可以定义在类上
    
泛型类的定义:
	/**
     * 泛型类
     */
    public class MyArrayList<E> {
        //就是把E当做某种数据类型使用
        private E ee;

        public E getEe() {
            return ee;
        }

        public void setEe(E ee) {
            this.ee = ee;
        }
    }
泛型类的使用:
	public class TestMyArrayList {
        public static void main(String[] args) {
            //1.使用泛型类,MyArrayList
            MyArrayList<String> arr = new MyArrayList<String>();
            //此时arr中集合对象中没有E了!!所有E都变成String
            arr.setEe("java");
            String ee = arr.getEe();
            System.out.println(ee);

            //2.使用泛型类,MyArrayList
            MyArrayList<Integer> arr1 = new MyArrayList<Integer>();
            //此时arr1中集合对象中没有E了!!所有E都变成Integer
            arr1.setEe(100);
            System.out.println(arr1.getEe());
        }
    }

泛型方法

泛型定义在某个方法上

泛型方法的定义:
	public class Dog {
        /**
         * 泛型方法
         */
        public <E> void show(E num){
            System.out.println(num);
        }
    }

泛型方法的使用:
	public class TestDog {
        public static void main(String[] args) {
            //1.创建Dog对象
            Dog dd = new Dog();
            //2.调用方法
            dd.show("java");
            dd.show(10);
            //严格的方式
            dd.<String>show("java");
            dd.<Integer>show(10);
        }
    }

泛型接口

泛型定义在某个接口上
    
泛型接口的定义:
	/**
     * 泛型接口
     */
    public interface MyInterface<MVP> {
        //在接口中就可以使用MVP
        public abstract void show(MVP mm);
        public abstract void eat(MVP mm);
    }

泛型接口的使用:
	//泛型接口的泛型,可以在以下两种情况中确定
    //a.定义一个实现类 实现 该接口时,确定MVP的具体类型
    class MyClass1 implements MyInterface<Integer>{
        //重写抽象方法
        @Override
        public void show(Integer mm) {

        }
        @Override
        public void eat(Integer mm) {

        }
    }

    //b.定义一个实现类 实现 该接口时,保留泛型
    class MyClass2<MVP> implements MyInterface<MVP>{

        @Override
        public void show(MVP mm) {

        }

        @Override
        public void eat(MVP mm) {

        }
    }
    //此时实现类 其实就是一个泛型类,创建该类的对象时,可以确定泛型的具体类型
    // MyClass2<String> mc = new MyClass2<String>();
    // MyClass2<Integer> mc = new MyClass2<Integer>();

	//c.丢弃泛型
	//c.也可以直接丢弃泛型,此时所有的泛型都会变成Object
    class MyClass3 implements MyInterface{
        @Override
        public void show(Object mm) {

        }
        @Override
        public void eat(Object mm) {

        }
    }

在开发我们很少自定义泛型类.泛型方法,泛型接口,所以我们的重点是别人定义好了一个泛型类(ArrayList<E>)

ArrayList<具体的类型> arr = new ArrayList<具体的类型>();

4.泛型统配符

a.什么是泛型统配符:
	当集合中泛型不确定为何种类型时,那么我可以使用泛型通配符,表示何种泛型均可
		ArrayList<String>
        ArrayList<Integer> 
        ArrayList<?>
        
public class TestDemo {
    public static void main(String[] args) {
        //1.定义三个集合
        ArrayList<String> arr1 = new ArrayList<String>();
        ArrayList<Integer> arr2 = new ArrayList<Integer>();
        ArrayList<Double> arr3 = new ArrayList<Double>();
        //2.调用方法
        method(arr1);
        method(arr2);
        method(arr3);
        //Java要求调用方法时,不仅要数据类型一样,泛型必须也一样,否则编译报错!!
    }

    //方法,要求该方法可以接收 以上三个集合中的任意一个
    public static void method(Collection<?> arr) {

    }
}

5.泛型的上下限

泛型上下限:
	<?> 什么泛型都是OK的
    <? extends Animal>,叫泛型的上限,表示该泛型必须是Animal本类或者其子类(Dog,Cat) 
    我们可以理解为: "<? <= Animal>"    
        
    <? super Student>,叫泛型的下限, 表示该泛型必须是Student本类或者其父类(Person,Object)   
    我们可以理解为: "<? >= Student>"  
        
举例:
public class TestDemo02 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();
        //Number是 Integer的父类
        // Object
        //   子类 String Number
        //               子类 Integer
        //调用方法1
        getElement1(list1); //OK
        getElement1(list2);
        getElement1(list3); //OK
        getElement1(list4);

        //调用方法2
        getElement2(list1); // 0
        getElement2(list2); // 0
        getElement2(list3); // 1
        getElement2(list4); // 1
    }

    //要求:泛型必须是Number 或者 Number的子类(上限)
    public static void getElement1(Collection<? extends Number> coll) {

    }

    //要求:泛型必须是Number 或者 Number的父类(下限)
    public static void getElement2(Collection<? super Number> coll) {

    }
}

四，数据结构

是容器保存数据的方式!!

我们需要掌握前四种数据结构

栈结构：先进后出,后进先出

队列结构：先进先出,后进后出

数组结构：查改快,增删慢!

链表结构：查改慢,增删快!

other------------------------other------------------------other------------------------other------------------------other------------------------

1.请问Collection接口下有哪些类型的集合？它们分别是什么？

是的。Collection接口中的方法，它的子接口List，Set都有，LIst接口和Set接口的实现类（子类）就自然拥有了Collection接口中定义的方法了。

请定义一个Collection类型的集合，存储以下字符串：

“JavaEE企业级开发指南”，”Oracle高级编程”，”MySQL从入门到精通”，

”Java架构师之路”

请编程实现以下功能：

使用迭代器遍历所有元素，并打印
使用迭代器遍历所有元素，筛选书名小于10个字符的，并打印；
使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印
如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名。

(注意：以上功能写在一个main()方法中，但请单独实现)

 public static void main(String[] args) {
        Collection allCol = new ArrayList<>();
        allCol.add("JavaEE企业级开发指南");
        allCol.add("Oracle高级编程");
        allCol.add("MySQL从入门到精通");
        allCol.add("Java架构师之路");

        //用迭代器遍历所有元素并打印
        System.out.println("\n1.值为：");
        Iterator iterator = allCol.iterator();
        while (iterator.hasNext()){
            Object value = iterator.next();
            System.out.print("  "+value);
        }

        //使用迭代器遍历所有元素，筛选书名小于10个字符的，并打印；
        System.out.println("\n2.筛选的字符为：");
        Iterator iterator01 = allCol.iterator();
        while (iterator01.hasNext()){
            String value = (String)iterator01.next();
            if (value.length()<10) {
                System.out.print("  " + value);
            }
        }

        //使用迭代器遍历所有元素，筛选书名中包含“Java”的，并打印
        System.out.println("\n3.筛选的包含java的为：");
        Iterator iterator02 = allCol.iterator();
        while (iterator02.hasNext()){
            String value = (String)iterator02.next();
            if (value.contains("Java")) {
                System.out.print("  " + value);
            }
        }

        //如果书名中包含“Oracle”，则删掉此书。删掉后，遍历集合，打印所有书名。
        for (int i=allCol.size()-1;i>=0;i--){
            String value = (String) ((ArrayList) allCol).get(i);
         if (value.contains("Oracle")){
             allCol.remove(value);
           }
        }
        System.out.println("\n4.筛选的数据为：");
        for (Object str : allCol) {
        System.out.print("  " + str);
        }
        }