java小白——集合框架

1、集合框架概述：

特点：

①可以存储不同的数据类型

②长度动态的

③内存空间不一定是连续的

④只能存储对象

Collection为集合层级的根接口。

Set是一个不能包含重复元素的集合；
List是一个有序集合，可以包含重复元素；

Map是一种key-value（键值对）结构的集合模型，不能包含重复的key值，每个key只能映射到一个value。

2、Collection中的一些方法的使用：

        //Collections 使用
        //随机排列集合中的元素
        Collections.shuffle(list);
        System.out.println(list);
        //将集合中的元素替换一个相同的元素
//        Collections.fill(list,100);
//        System.out.println(list);
        //打印集合中指定元素的个数
        int frequency = Collections.frequency(list,1);
        System.out.println(frequency);

        //将集合中的元素反转
        Collections.reverse(list);
        System.out.println(list);

        //交换集合中的两个元素位置
        Collections.swap(list,1,2);
        System.out.println(list);

        //将集合中的元素平移指定位数，（正数向右平移，负数向左平移）
        Collections.rotate(list,1);
        System.out.println(list);

        ArrayList list1 = new ArrayList();
        for(int j = 5; j < 15; j++ ) {
            list1.add(j);
        }
        //第二个集合中的元素会把第一个集合中的元素覆盖掉（第二个集合的长度不能大于第一个集合）
        Collections.copy(list1,list);
        System.out.println(list1);

3、list：

• List接口的实现类：
  * 1.ArrayList(底层为数组结构)
  * 查、改效率高
  * 2.LinkedList（底层为双向链表）
  * 既能向后找，也能向前找（记住前一个的地址，也记住后一个地址）。
  * 增、删效率高
  * 3.Vector(底层为数组结构、线程安全（一个时间只能有一个线程进行，其他进程 只能排队等待）、访问效率低)

        ArrayList list = new ArrayList();//给出了默认长度0
        //1.添加元素
        /**
         * add:
         *  1、现将底层数组扩容（超出初始数组长度）
         *  2、将元素赋值到数组对应位置
         *  3、返回true
         * */
        list.add(10);
        list.add("abc");//可以存不同的引用（对象）数据类型
        list.add(0,3);//（为指定位置插入元素，只能挨着插入，不能跨越式插入）把12插入第0个位置
        list.add(0,3);
        //获取元素
        /**
         *
         * */
        System.out.println(list.get(0));

        //修改元素
        /**
         * 返回值是修改之前的值
         * */
        Object e = list.set(1,"first");
        System.out.println(list.get(1));
        System.out.println(e);
        //删除元素
        //按照下标删除，返回值是删除之前的元素
        list.add(0,3);
        /**
         * 如果元素为整数，
         * remove的参数为int，按照下标删除；
         * 参数为integer，就是按照元素删除
         * 装箱（把int转换为integer）；拆箱（把integer转换为int）
         * */
        //按照元素值删，返回的是Boolean类型的值
        Object element = list.remove(new Integer(3));//按照元素删,一次只能删除最左边的一个对应元素。

Iterator（迭代器）：

//迭代器:将Collection集合的遍历统一起来
        Iterator<String> iterator = list.iterator();
        //判断是否有下一个元素,并没有真正获取值
        iterator.hasNext();
        boolean hasNext = iterator.hasNext();
        //如果有，返回true，如果没有，返回false
        System.out.println(hasNext);
        //获取下一个元素
        iterator.next();
        /**
         * 通过迭代器删除元素，不会影响整个遍历过程
         * */
        while (iterator.hasNext()) {
            String e = iterator.next();
            //删除当前迭代到的对象
//            iterator.remove();
            System.out.println(list.size());
        } //一次迭代完成，迭代器指针指向最末，想要继续迭代，需要重新创建迭代对象
        System.out.println(list.size());
        //list 集合  独有的迭代器
        ListIterator<String> listIterator = list.listIterator();
        System.out.println("----------------");
        while(listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
        System.out.println("-------------");
        while(listIterator.hasPrevious()) {
            System.out.println(listIterator.previous());
        }
        //listIterator独有的一些方法
//        listIterator.add("liguocheng");
//        listIterator.previousIndex();
//        listIterator.next();
        //其他对象方法
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("aa");
        list1.add("bb");
        list1.add("bb");
        list1.add("cc");
        list1.add("dd");
        //根据元素获取下标，第一次出现时的下标
        //返回值为-1，说明该元素不存在
        int index = list1.indexOf("bb");
        System.out.println(index);
        System.out.println(list1.lastIndexOf("bb"));
        list1.contains("aa");//是否包含该元素
        System.out.println(list1.contains("aa"));
        boolean contains = list1.contains("bb");
        System.out.println(contains);
        list1.isEmpty();//判断是否为空集合：true 代表里面没有元素，false 代表里面有元素。
        System.out.println(list1.isEmpty());

        //删除里面的所有元素
        list1.clear();
        System.out.println(list1.isEmpty());
        

数组和集合之间的转换

 //数组和集合之间的转换
        Object[] array = list1.toArray();

        for(Object o : array) {
            System.out.println(o);
        }
        String[] arr = new String[list1.size()];
        list1.toArray(arr);
        System.out.println("-----------");
        for(String str : arr) {
            System.out.println(str);
        }

aslist的作用：

 /**
         * aslist: 如果参数为基本数据类型数组
         * 将整个数组作为集合的一个元素加入返回值的集合中
         * 如果是对象类型的数组，将数组中的元素转换到集合中
         * */
        int[] array_int = {1,2,3};
        List list = Arrays.asList(array_int);
        System.out.println(list);
        Integer[] array_integer = {1,2,3};
        List list3 = Arrays.asList(array_integer);
        System.out.println(list3);

Set(集合)：

特点： ①集合是没有角标的

​ ②集合中不能放置重复的对象（可以用来去重）

​ ③不允许连续调用两次remove，在调用一次remove之后，需要先调用一次next之后再remove。

public class Main {

    //容器 java 给出的承载对象类型的一种ADT
    //abstract date type

    public static void main(String[] args) {

        Set<String> myset = new HashSet<>();//HashSet 是无序的 LinkedHashSet (链表哈希算法，按添加顺序加入，无下标)
        myset.add("liguocheng");
        myset.add("liguocheng"); //Set中不能存放相同的元素，因为Set中没有角标
        myset.remove("liguocheng");
        System.out.println(myset.size());
        myset.add("aaaaa");
        myset.add("aaabzxvzc");
        myset.add("aaacsdds");
        myset.add("adfdfda");
        myset.add("afdfa");
        System.out.println(myset.size());
        myset.remove("aaaaa");
        System.out.println(myset.size());
//        for(String item : myset) {
//            System.out.println(item);
//        }

        Iterator<String> iterator = myset.iterator();
        iterator.next();
        iterator.remove();
        for(String item : myset) {  //foreach底层使用的是迭代器（用while循环）
            System.out.println(item);
        }
        
    }

Map：

public class Main {

    public static void main(String[] args) {

        //放置内容的时候，是用的是单一的泛型来确定放置的内容是什么类型
        List<String> lists = new LinkedList<>();
        lists.add("liguocheng");
        lists.add("wangbin");
        lists.get(0);

        //map中存的是K-V(键值对)对， 我们放置的时候，确定一下key值和V值，这两值一一对应，
        //当我们取值地时候，是用的是key值来取出V值

        //map叫做映射表
        Map<String,String> map = new HashMap<>();
        //map中的定位，求长，替换

        map.put("liguocheng","wangbin");
        System.out.println(map.get("liguocheng"));//通过key值定位，获取值
        //map中的key值不能重复，若重复了则会覆盖掉之前的V值
        System.out.println(map.size());

        System.out.println(map.containsKey("liguocheng"));//查询的是一个对象
        System.out.println(map.isEmpty());//判断是否有值

        //将map中的值放入list中（使用vaules方法），之后便可以使用角标获取值
        List<String> list = new ArrayList<>();
        list.addAll(map.values());
        System.out.println(map.get(0));

        //map中的方法：确认是否有键值，确认是否有值，确认是否为空，长度，放置内容，取出内容，删除内容，转换容器等方法

        Set<String> keys = map.keySet();//这个set是hashset
        for(String item : keys) {
            System.out.println(item + ":" + map.get(item));
        }                        //叫做纵切遍历方式（先把key的那一列当做set拿出来，后面的value值也就对映拿出来了）

        Set<Map.Entry<String,String>> entries = map.entrySet();
        for(Map.Entry<String,String> item : entries) {
            System.out.println(item.getKey() + ":" + item.getValue());
        }                        //横切遍历方式（每次拿出它的键值对）
        System.out.println();
    }

栈：

public class MySort {

    public static void main(String[] args) {

        Integer[] i = {1,2,3,4,5};
        //Arrars.copyof 方法 就算超出数组长度也不会出错，只会补上默认值
        System.out.println(Arrays.toString(Arrays.copyOf(i,10)));

        System.out.println(Arrays.toString(Arrays.copyOfRange(i, 2, 4)));


        Stack<String> strings = new Stack<>();
        strings.push("liguocheng");
        strings.push("wangyanwei");
        strings.push("wangyongjie");
        strings.push("zhangaoqi");
        strings.add("wangbin");

        //pop  弹出栈顶元素，改变了栈长度
        //peek  取到栈顶元素，不改变栈长度
        System.out.println(strings.size());
        System.out.println(strings.pop());
        System.out.println(strings.size());
        System.out.println(strings.peek());
        System.out.println(strings.size());

        //遍历栈元素
        for(String s : strings) {
            System.out.println(s);
        }
    }