java 集合框架和泛型

清疚 2022-06-09 13:38 240阅读 0赞

//常用的集合类:

Collection 为接口类的父类,子类包括:Set接口和List接口

Set(集):集合中的对象不按特定的方式排序,不允许元素重复,

List(列表):集合中的对象按照索引位置排序,允许元素重复,有序的

List集合比Collection多一部分关于下标的操作,例如插入元素到什么位置,根据位置删除元素

Map(映射):集合中每一个元素都包含一对key和value对象,不允许key对象重复,值对象可以重复![20170906211341107][]

Colllection集合的使用

//1.创建实现接口类的对象
            Collection collection = new ArrayList();//多态
            Collection collection1 = new ArrayList();//多态
    
            //2.添加元素
            collection.add(123);//填一个对象
            collection1.add("abc");
            collection1.add("ccc");
            collection.addAll(collection1);//填一个集合
            System.out.println(collection);
    
            //3.删除元素
            collection.remove("abc");
            System.out.println(collection);
    
            //4.判断集合元素
            boolean bool = collection1.contains("abc");
            System.out.println("----"+bool);
    
            //5.判断是否为空
            boolean bool1 = collection1.isEmpty();
            System.out.println(bool1);
    
            //6.交集
            System.out.println(collection.retainAll(collection1));
            System.out.println(collection);
            System.out.println(collection1);
    
            //7.将集合转换为数组
            Object[] objs = collection.toArray();
            System.out.println(objs);

注意:如果删除,添加操作比较多,就用linkedList  
            如果查找,更新操作比较多,就用Arraylist

//list使用:

//1.定义一个List
            List list = new ArrayList();//多态
    
           //2.添加元素
            list.add(0, "abc");
            System.out.println(list);
            //3.插入元素
            list.add(1, "like");//根据下标插入元素
            System.out.println(list);
            //4.删除元素
            Object object = list.remove(0);//将要删除的元素
            System.out.println(object);
            //5.修改元素
            //通过指定的下标修改元素
            Object setObject = list.set(0, "weiwei");
            System.out.println(setObject);
            System.out.println(list);//修改之后的内容
            //6.获取元素
            Object getObject = list.get(0);
            //7.获取子列表
            List sublList = list.subList(0,1);
            System.out.println(sublList);

//ArrayList的使用

// ArrayList arrayList = new ArrayList();
            //添加元素
            arrayList.add("1");
            arrayList.add("2");
            arrayList.add("3");
            
            //删除元素
            arrayList.remove(1);//根据下标删除元素
            arrayList.remove("2");//根据元素删除元素
            
            //更新元素
            arrayList.set(0, "更新元素");
            
            //查找元素
            Object object = arrayList.get(1);
            
            //是否包含某元素
            boolean isContain = arrayList.contains("更新元素");
    
            //LinkedList的使用
    
            //LinkedList arrayList = new LinkedList();
            //添加元素
            arrayList.add("1");
            arrayList.add("2");
            arrayList.add("3");
            
            //删除元素
            arrayList.remove(1);//根据下标删除元素
            arrayList.remove("2");//根据元素删除元素
            
            //更新元素
            arrayList.set(0, "更新元素");
            
            //查找元素
            Object object = arrayList.get(1);
            
            //是否包含某元素
            boolean isContain = arrayList.contains("更新元素");
            
            //元素个数
            int size = arrayList.size();
    
       
            //元素个数
            int size = arrayList.size();

//for循环遍历

for (int i = 0; i < list.size(); i++) {
                System.out.println("list的索引值为:" + i);
                System.out.println(list.get(i));
            }
            //forEach遍历
            for (Object object2 : list) {
                System.out.println(object2);
            }

注意:在迭代器中不可以删除元素,删除原素,会出现ConCurrentModeificationExcption错误 //iterator()遍历迭代器

//iterator()遍历
            //获取对集合进行迭代的迭代器
            Iterator iterator = list.iterator();
            //判断是否有进行迭代的元素
            while (iterator.hasNext()) {
                //取出迭代的下一个元素
                Object obj = iterator.next();
                System.out.println(obj);
            }

//泛型

1.泛型里头没有继承

2.通配符 ?extends +子类及其本身   ? super+父类及其本身.

3.泛型的作用：把运行时的错误提前到编译

public class Test06 {
    
    	/**
    	 * 统配符
    	 * @param args
    	 */
    	//在泛型里没有继承
    	public static void main(String[] args) {
    		
    		ArrayList<List>list = new ArrayList<List>();
    	
    		//? 通配符 extends Number的子类及它本身
    		ArrayList<? extends Number> list2 = new ArrayList<Integer>();
    		ArrayList<? extends B>list4 = new ArrayList<C>();
    		ArrayList<? extends B>list5 = new ArrayList<B>();
    		//? 通配符 super 的父类及它本身
    		ArrayList<? super B>list3 = new ArrayList<A>();
    	}
    }
    class A{
    	
    }
    class B extends A{
    	
    }
    class C extends B{
    	
    }

4,泛型常使用 T,E,K,V(大写字母)来表示

5.泛型可以用来当做返回值,类,变量

// 定义泛型类
    public class Arr <T,E> {
        T[] arr;
        
        public <W> W name(W a) {
            return a;
        }
         
        // T 作为参数和返回值
        T add (T a, E b) {
            return a;
        }
        public static void main(String[] args) {
            Arr<Integer,String> temp  = new Arr<Integer,String>();
            temp.arr = new Integer[10];
            Integer item = temp.add(1, "2");
        }
    }

[20170906211341107]: /images/20220609/5a5ab8d9fcd0428a81a15d9c1992d274.png