zoukankan      html  css  js  c++  java
  • Collectio集合,List《ArrayList,LinkedList》

    集合:

    Collection类
    package com.collection.demo;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.Iterator;
    
    /**
     * 数组: 存储同一类型的元素组成集合,固定长度,数组中元素可以是基本数据,也可以是对象。
     * 集合: 存储不同类型对象的容器, 长度可变,集合中的元素必须是Object的子类,不能是基本数据类型。
     * 首字母大写都是对象
     * @author Administrator
     *
     */
    public class CollectionDemo {
        /**
         *     boolean add(E o);  
            boolean remove(Object o);  
            int size();  
            boolean contains(Object o);  
            boolean isEmpty();  
            void clear();  
            Iterator<E> iterator();
            boolean addAll(Collection c);  
            boolean retainAll(Collection c); 
             boolean removeAll(Collection c);
         */
        
        public static void main(String[] args) {
            // 创建Collection对象
            Collection collection = new ArrayList();
            collection.add("AAA");
            collection.add(new Object());
            collection.add(1.0); // 自动装箱 new Integer(1); // 实体尽量使用包装类
            collection.add("AAA");
            System.out.println(collection); // 有一个学生
            
            // 获取集合元素个数
            System.out.println(collection.size());
            
            // 判断是否存在某个对象
            String obj = "AAA";
            boolean flag = collection.contains(obj);
            System.out.println(flag?"存在":"不存在");
            // 移除某个对象, 首次查找的对象会被移除
            flag =  collection.remove(obj);
            System.out.println(flag?"移除成功":"移除失败");
            
            // 遍历合中的元素
            Iterator it = collection.iterator();
            while (it.hasNext()) {
                System.out.print(it.next() + " ");
            }
            System.out.println("\r\n");
            
            // 清空集合中的元素
            // collection.clear();
            // collection = null;
            
            // 判断集合是否为空,没有关心对象的本身是null
            // isEmpty() 判断size==0
            System.out.println(collection.isEmpty()?"为空":"不为空");
            
            // Arrays 数组操作的工具类,asList 把一个数组转换为一个集合
            
            // 批量添加一个集合到一个集合中
            Collection cl = Arrays.asList("BBB","CCC","DDD");
            collection.addAll(cl); // 添加的集合中每一个元素
            collection.add(cl); // 添加的是一个对象
            System.out.println(collection);
            
            // 批量移除
            Collection cl1 = Arrays.asList(new Double(1),"AAA","BBB");
            collection.removeAll(cl1);
            System.out.println(collection);
            
            // 获取2个集合之间交集
            collection.retainAll(Arrays.asList("CCC","DDD"));
            System.out.println(collection);
        }
        
    }

     List:

    package com.collection.demo.list;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.Iterator;
    import java.util.List;
    import java.util.ListIterator;
    
    /**
     * List接口:
     * 特点: 元素是有序,可以包含重复元素,基于数组实现
     * @author Administrator
     *
     */
    public class ArrayListDemo {
        public static void main(String[] args) {
            List list = new ArrayList(2);
            // 添加元素
            list.add("AAA"); // 添加单个元素
            list.add("BBB"); // 添加单个元素
            list.add("CCC"); // 添加单个元素
            list.add(1, "BVV"); //插入单个元素
            // 批量添加集合
            list.addAll(Arrays.asList(1,1.1D,1.1F));
            // 批量插入集合
            list.addAll(3, Arrays.asList("VVC","BVC"));
            
            // 删除元素
            list.remove(0); // 通过对象的下标移除
            list.remove(new Integer(1)); // 根据对象移除
            list.removeAll(Arrays.asList("BBB","CCC")); // 批量移除
            
            System.out.println(list);
            // 判断元素对象是否存在
            boolean flag = list.contains("VVC");
            System.out.println(flag ? "存在":"不存在");
            
            // 批量判断是否存在
            flag = list.containsAll(Arrays.asList("VVC",1.1));
            System.out.println(flag ? "存在":"不存在");
            
            // 判断集合元素个数否为0
            System.out.println(list.isEmpty());
            
            // 获取单个指定下标元素
            System.out.println(list.get(3));
            
            // 遍历集合
            for (int i = 0; i < list.size(); i++) {
                System.out.print(list.get(i)+" ");
            }
            System.out.println("\r\n");
            Iterator iterator = list.iterator();
            while (iterator.hasNext()) {
                System.out.print(iterator.next()+" ");
            }
            
            System.out.println("\r\n");
            ListIterator listIterator = list.listIterator();
            while (listIterator.hasNext()) {
                System.out.print(listIterator.next()+" ");
            }
            System.out.println("\r\n");
            System.out.println("====================");
            // 反向迭代。必须把游标移动到末尾
            ListIterator listIterator1 = list.listIterator(list.size());
            while (listIterator1.hasPrevious()) {
                System.out.print(listIterator1.previous()+" ");
            }
            System.out.println("\r\n");
            System.out.println("---------------------");
            // 增强for循环
            for (Object obj : list) {
                System.out.print(obj+" ");
            }
            
            // 查询 -> 下标
            // 查找 -> 下标
            
        }
    }
    package com.collection.demo.list;
    
    import java.util.Arrays;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.ListIterator;
    
    public class LinkedListDemo {
        public static void main(String[] args) {
            List list = new LinkedList();
            // 添加元素
            list.add("AAA"); // 添加单个元素
            list.add("BBB"); // 添加单个元素
            list.add("CCC"); // 添加单个元素
            list.add(1, "BVV"); // 插入单个元素
            // 批量添加集合
            list.addAll(Arrays.asList(1, 1.1D, 1.1F));
            // 批量插入集合
            list.addAll(3, Arrays.asList("VVC", "BVC"));
    
            // 删除元素
            list.remove(0); // 通过对象的下标移除
            list.remove(new Integer(1)); // 根据对象移除
            list.removeAll(Arrays.asList("BBB", "CCC")); // 批量移除
    
            System.out.println(list);
            // 判断元素对象是否存在
            boolean flag = list.contains("VVC");
            System.out.println(flag ? "存在" : "不存在");
    
            // 批量判断是否存在
            flag = list.containsAll(Arrays.asList("VVC", 1.1));
            System.out.println(flag ? "存在" : "不存在");
    
            // 判断集合元素个数否为0
            System.out.println(list.isEmpty());
    
            // 获取单个指定下标元素
            System.out.println(list.get(3));
    
            // 遍历集合
            for (int i = 0; i < list.size(); i++) {
                System.out.print(list.get(i) + " ");
            }
            System.out.println("\r\n");
            Iterator iterator = list.iterator();
            while (iterator.hasNext()) {
                System.out.print(iterator.next() + " ");
            }
    
            System.out.println("\r\n");
            ListIterator listIterator = list.listIterator();
            while (listIterator.hasNext()) {
                System.out.print(listIterator.next() + " ");
            }
            System.out.println("\r\n");
            System.out.println("====================");
            // 反向迭代。必须把游标移动到末尾
            ListIterator listIterator1 = list.listIterator(list.size());
            while (listIterator1.hasPrevious()) {
                System.out.print(listIterator1.previous() + " ");
            }
            System.out.println("\r\n");
            System.out.println("---------------------");
            // 增强for循环
            for (Object obj : list) {
                System.out.print(obj + " ");
            }
            
            // 删除
            // 插入
        }
    
    }

     栈

    package com.demo;
    
    import java.util.Stack;
    
    public class StackDemo {
        public static void main(String[] args) {
            // 先进后出来
            Stack stack = new Stack();
            
            // 压栈
            stack.push("AAAA");
            stack.push("BBBB");
            stack.push("CCCC");
            stack.push("DDDD");
            // 弹栈(从栈中移除该元素)
            System.out.println(stack.pop());
            // 获取栈顶元素(获取栈上面最先出来的元素)
            System.out.println(stack.peek());
            // 
            System.out.println(stack);
        }
    }

    队列

    package com.demo;
    
    import java.util.LinkedList;
    import java.util.Queue;
    
    /**
     * 队列结果
     * @author Administrator
     *
     */
    public class QueueDemo {
        public static void main(String[] args) {
            // 先进先出
            Queue queue = new LinkedList();
            // 入列
            queue.offer("AAAA");
            queue.offer("BBBB");
            queue.offer("CCCC");
            queue.offer("DDDD");
            // 出列
            System.out.println(queue.poll());
            // 获取列头
            System.out.println(queue.peek());
            
            System.out.println(queue);
        }
    }

    模拟队列,栈

    package com.demo;
    
    import java.util.LinkedList;
    
    public class LinkedListDemo {
        public static void main(String[] args) {
            LinkedList linkedList = new LinkedList();
            // 模拟栈
            // 压栈
            linkedList.addFirst("AAAA");
            linkedList.addFirst("BBBB");
            linkedList.addFirst("CCCC");
            linkedList.addFirst("DDDD");
            // 弹栈
            System.out.println(linkedList.removeFirst());
            // 获取栈顶元素
            System.out.println(linkedList.getFirst());
            System.out.println(linkedList);
            
            System.out.println("-------------------------------");
            LinkedList linkedList1 = new LinkedList();
            // 模拟栈
            // 压栈
            linkedList1.addLast("AAAA");
            linkedList1.addLast("BBBB");
            linkedList1.addLast("CCCC");
            linkedList1.addLast("DDDD");
            // 弹栈
            System.out.println(linkedList1.removeFirst());
            // 获取队列头元素
            System.out.println(linkedList1.getFirst());
            System.out.println(linkedList1);
        }
    }    
  • 相关阅读:
    Java实现 LeetCode 697 数组的度(类似于数组的map)
    Java实现 LeetCode 697 数组的度(类似于数组的map)
    Java实现 LeetCode 697 数组的度(类似于数组的map)
    Java实现 LeetCode 696 计数二进制子串(暴力)
    Java实现 LeetCode 696 计数二进制子串(暴力)
    Java实现 LeetCode 696 计数二进制子串(暴力)
    Java实现 LeetCode 695 岛屿的最大面积(DFS)
    Java实现 LeetCode 695 岛屿的最大面积(DFS)
    PHP serialize() 函数
    PHP print_r() 函数
  • 原文地址:https://www.cnblogs.com/sunBinary/p/10480179.html
Copyright © 2011-2022 走看看