11持有对象-Java编程思想

我不是女神ヾ 2022-09-25 13:17 125阅读 0赞

Java提供一套相当完整的容器类来存储数量不确定的对象。集合类：list,set.queue,map。通过使用泛型，可以在编译器防止将错误类型的对象放置到容器中去，在取出的时候也会帮忙转型。

Collection,一个独立元素序列。List按照插入的顺序保存元素，set不能有重复的元素，Queue按照队列的规则确定对象顺序。

Map键值对，允许用键来找值。

HashSet\\TreeSet\\LinkedHashSet都是Set类型。HashSet是最快的获取元素的方式，顺序看起来杂乱无章（通常只用关心某个元素是否是其成员，不关心顺序）。TreeSet将元素存储在红黑树数据结构中，按照结果的升序保存对象。LinkedHashSet因为查询速度也使用了hash，同时使用了链表来维护顺序，按照添加的顺序保存对象。

HashMap是最快的获取元素的方式，顺序看起来杂乱无章。TreeMap按照结果的升序保存对象。LinkedHashMap按照添加的顺序保存键，同时还保留了HashMap的查询速度。

List在Collection的基础上添加了较多的方法。ArrayList 和LinkedList两种，前者在随机访问方面有较大优势，在插入和移除的时候较慢。后者插入和删除的代价较低，顺序访问也较快，但是对于随机访问则相对较慢。

迭代器（也是一种设计模式）：我们在设计的时候一直考虑的是，怎么去抽象到更高的高度，不对确切的内容进行编程，而是抽象到更高的高度，方便复用。接收对象容器并使用它，使每个对象都能执行操作。

class Pets{
        List<String> pets=new ArrayList<>();
        public List<String> getPets(){
            pets.add("pet1");
            pets.add("pet2");
            pets.add("pet3");
            return pets;
        }
    
    }
    
    public class IteratorTest {
        public static void display(Iterator<String> it){
            while (it.hasNext()){
                String s=it.next();
                System.out.print(s);
            }
            System.out.println();
        }
        public static void display(Collection<String> c){
            for (String s:c) {
                System.out.print(s);
            }
            System.out.println();
        }
        public static void main(String args[]){
            Pets p=new Pets();
            List<String> petsList=p.getPets();
            Set<String> petsSet=new HashSet<>(petsList);
            Map<String,String> petsMap=new HashMap<>();
            String[] name=("cat,pig,dog".split(","));
            for (int i=0;i<3;i++){
                petsMap.put(name[i],petsList.get(i));
            }
            display(petsList);
            display(petsSet);
            display(petsList.iterator());
            display(petsSet.iterator());
            System.out.println(petsMap);
            System.out.println(petsMap.keySet());
            display(petsMap.keySet());
            display(petsMap.values());
            display(petsMap.values().iterator());
    
        }
    }

迭代器就是为了达到这样的目的。迭代器是一个对象，遍历并选择其中的对象。不用关心底层的结构。Java的interator只能单向移动。使用方法interator()要求容器返回一个Interator对象，其准备好返回序列的第一个元素，使用next返回下一个，hasnext检查是否还有下一个，remove将元素删除。在调用remove前一定要调用next。

ListInterator是更强大的interator的子类型。可以双向移动。

Linkedlist额外提供了栈，队列，双端队列的方法。

Stack栈，后进先出的容器LIFO,自助餐托盘。实际上LinkedList就能当栈来使用。

public class Stack<T> {
        //大概的了解栈的功能,了解本质上Linkedlist是可以实现栈的功能的
        private LinkedList<T> storage=new LinkedList<>();
        public void push(T t){storage.add(t);}
        public T peek(){return storage.getFirst();}
        public T pop(){return storage.removeFirst();}
        public boolean isEmpty(){return storage.isEmpty();}
        public String toString(){return  storage.toString();}
    }

public class StackTest {
        public static void main(String args[]){
            java.util.Stack<String> stack=new Stack<>();
            for (String s:"my name is haha".split(" ")
                 ) {
                stack.push(s);
            }
            while (!stack.isEmpty()){
                System.out.println(stack.pop());
            }
        }
    }

Set不保存重复的元素，实际上set就是collection。

Map与其他的Collection一样，很容易就扩展为多维的形式。可多重嵌套使用。例如跟踪某个拥有多个宠物的人，Map<Person,List<Pet>>.Map可以返回它的key的Set，它的键值对的set。keyset（）方法产生了前者的set集合，可以方便用foreach语法进行遍历。

public class MapTest {
        public static void test1(){
            Random random=new Random(47);
            Map<Integer,Integer> m=new HashMap<>();
            for(int i=0;i<1000;i++){
                int r= random.nextInt(20);
                Integer freq=m.get(r);
                m.put(r,freq==null?1:freq+1);//这种语法有点意思
            }
            System.out.println(m);
        }
        public static void test2(){
            Map<String,Animal> map=new HashMap<>();
            map.put("cat",new Animal("miao"));
            map.put("dog",new Animal("wang"));
            System.out.println(map);
            Animal dog=map.get("dog");
            System.out.println(dog);
            System.out.println(map.containsKey("cat"));
            System.out.println(map.containsValue(dog));
        }
        public static void main(String args[]){
            test1();
            test2();
        }
    }
    
    
    class Animal{
        String name;
        public Animal(String name){
            this.name=name;
        }
    }

Queue队列，典型的先进先出FIFO，在并发编程中特别重要。实际上LinkedList就能当队列来使用。注意还存在PriorityQueue即是优先级队列。队列规则是给定一组队列中的元素的情况下，下一个弹出队列元素的规则。先进先出声明的是下一个元素应该是等待时间最长的元素。优先级队列返回的元素是最需要的元素，如飞机场某飞机要起飞，该飞机的乘客可以优先登机。当优先队列调用offer方法进行插入对象的时候，对象会自动根据规则排序。同时peek，poll，remove的时候也是获取的优先级最高的。注意可以通过自己提供Comparator方法来修改顺序。

public class QueueTest {
        public static void main(String args[]){
            Queue<Integer> queue=new LinkedList<>();
            //我注意到,如果是对于Stack而言,后面的实现我写出Stack<String> s=new Stack<>();是默认OK的
            //但是对于Queue,我写了相似的结构以后,马上出了一堆方法要我覆盖
            //offer方法将一个元素插入到队尾或者返回false
            //peek方法和element方法都在不移除的情况下返回队头
            //peek方法在队列为空的时候返回null,而element方法返回NoSuchElementException异常
            //poll和remove方法将移除并返回对头,但poll方法在队列为空的时候返回null,而remove抛出NoSuchElementException异常
            Random random=new Random(47);
            for (int i=1;i<10;i++){
                queue.offer(random.nextInt(i+10));
            }
            printQ(queue);
            System.out.println(queue);
            Queue<Character> qc=new LinkedList<>();
            for (char c:"Helloworld".toCharArray()){
                qc.offer(c);
            }
            System.out.println(qc);
            printQ(qc);
        }
        public static void printQ(Queue q){
            while (q.peek()!=null){
                System.out.println(q.remove());
            }
        }
    }

foreach可以用于数组，也可以用于任何collection对象。之所以能够正常工作，是因为Javase5引入了新的Iterator接口，该接口包含一个能产生Iterator的iterator方法。如果你创建了Iterable实现的类，都可以用于foreach。

Java提供了大量关于持有对象的操作，数组将数字与对象关联起来。保存类型明确的对象，查询对象的时候无需类型转换。数组一旦形成就不能改变大小。

public class ForeachCollections {
        public static void main(String args[]){
            Collection<String> cs=new LinkedHashSet<>();
            Collections.addAll(cs,"go home or go big".split(" "));
            for (String s:cs
                 ) {
                System.out.println(" "+s+" ");
            }
        }
    }

只要实现了Iterable类就可以用于foreach中。

public class IterableClass implements Iterable<String> {
        //这段很精彩,要背背
        //返回了实现Iterator<String>的匿名内部类的实例
        protected String[] words=("you should study hard so you can go big".split(" "));
        public Iterator<String> iterator(){
            return new Iterator<String>() {
                private int index=0;
                public boolean hasNext() {
                    return index<words.length;
                }
                public String next() {
                    return words[index++];
                }
                public void remove(){
                    throw new UnsupportedOperationException();
                }
            };
        }
        //注意这个地方的ItearbleClass
        public static void main(String args[]){
            for (String s:new IterableClass()
                 ) {
                System.out.println(s);
            }
        }
    }

Collection保存单一的元素，而map保存相关联的键值对。有了Java泛型就可以指定容器中存储对象的类型，并且取出元素时候无需进行类型转换。容器大小可自动调整，容器不能存放基本数据类型，但是包装机制可以实现双向转换。各种栈和队列的行为，由linkedlist提供支持。

map是一种将对象（而非数字）与对象相关联的设计。hashmap用于快速访问，treemap用于保持键始终是排序状态，linkedhashmap保持插入的顺序同时也提供快速访问的支持。

Set不接受相同的元素。hashset快速查询，treeset保持排序状态，linkedhashset保持插入顺序也提供快速访问机制。