java讲义枚举弱引用集合 ArrayDeque

枚举：枚举类默认有一个values方法，返回该枚举的所有的实例SeasonEnum.values()

switch可以是任何枚举类型

枚举例子：

package javajiangyi;

public enum enumTest {
    PLUS{
        public double eval(double x,double y){
            return x+y;
        }
    },
    MINUS{
        public double eval(double x,double y){
            return x-y;
        }
    },
    TIMES{
        public double eval(double x,double y){
            return x*y;
        }
    },
    DIVIDE{
        public double eval(double x,double y){
            return x/y;
        }
    };
    //Spring,summer,fall,winter;
    //抽象方法为不同的枚举值提供不同的实现
    public abstract double eval(double x,double y);
    public static void main(String args[]){
        System.out.println(enumTest.PLUS.eval(3,4));
        System.out.println(enumTest.MINUS.eval(5,4));
    }

}

弱引用:

弱引用对象的存在不会阻止它所指向的对象被垃圾回收器回收。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。

现在有一个Product类代表一种产品，这个类被设计为不可扩展的，而此时我们想要为每个产品增加一个编号。一种解决方案是使用HashMap<Product, Integer>。于是问题来了，如果我们已经不再需要一个Product对象存在于内存中（比如已经卖出了这件产品），假设指向它的引用为productA，我们这时会给productA赋值为null，然而这时productA过去指向的Product对象并不会被回收，因为它显然还被HashMap引用着。所以这种情况下，我们想要真正的回收一个Product对象，仅仅把它的强引用赋值为null是不够的，还要把相应的条目从HashMap中移除。显然“从HashMap中移除不再需要的条目”这个工作我们不想自己完成，我们希望告诉垃圾收集器：在只有HashMap中的key在引用着Product对象的情况下，就可以回收相应Product对象了。显然，根据前面弱引用的定义，使用弱引用能帮助我们达成这个目的。我们只需要用一个指向Product对象的弱引用对象来作为HashMap中的key就可以了。

Product productA = new Product(...);
WeakReference<Product> weakProductA = new WeakReference<>(productA);

Product product = weakProductA.get();

软引用：内存不足，可能回收，内存足够，不会回收

弱引用：当垃圾回收机制运行时，不管内存是否足够，总是回收该对象所占用的内存

虚引用：虚引用主要用于跟踪对象被垃圾回收时的状态，虚引用不能单独使用，必须和引用队列联合使用。

Calendar类：

扫描二维码关注公众号，回复： 2692720 查看本文章

该类被abstract所修饰，说明不能通过new的方式来获得实例，对此，Calendar提供了一个类方法getInstance

Calendar rightNow = Calendar.getInstance();

public class CalendarTest {
    public static void main(String args[]){

        Calendar calendar=Calendar.getInstance();
        calendar.set(2018,7,1);
        System.out.println("test:"+calendar.getTime());
        //当字段超出他的范围，自动上位
        calendar.add(MONTH,6);
        System.out.println("test2:"+calendar.getTime());

    }
}

集合：

iterator的迭代

lambda表达式的迭代:

 Collection books=new HashSet();
        books.add("java");
        books.add("c");
        books.add("c++");
        Iterator it=books.iterator();
        it.forEachRemaining(obj-> System.out.println(obj));

java8新增的Predicate操作集合：

removeI法（Predicate filter)Perdicate是函数式接口，可以使用lanbda表达式作为参数

例子使用Perdicate来过滤集合

 Collection books=new HashSet();
        books.add("java");
        books.add("c13314");
        books.add("c++2313");
        books.removeIf(ele->((String)ele).length()<6);
        System.out.println(books);

ArrayDeque类

ArrayDeque实现了Deque接口，内部使用一个可调整大小的数组来存放元素。数组没有容量限制，必要的时候数组的容量会增加。ArrayDeque不是线程安全的。不允许添加Null元素。当ArrayDeque 作为一个栈来使用的时候，ArrayDeque 可能会比Stack 快。当ArrayDeque 作为队列使用的时候，可能会比 LinkedList 速度要快。

该类可以当做栈和队列使用

例子：

 public static void main(String args[]){
        ArrayDeque stack=new ArrayDeque();
        //模拟栈
        stack.push("java");
        stack.push("c++");
        stack.push("c");
        System.out.println(stack);
        //模拟队列
        ArrayDeque queue=new ArrayDeque();
        queue.offer("java");
        queue.offer("c++");
        queue.offer("c");
        System.out.println(queue);
    }

输出结果：

[c, c++, java]
[java, c++, c]

LinkedHashMap实现类

可记住key_value对的添加顺序

例子：

 LinkedHashMap score=new LinkedHashMap();
        score.put("语文",80);
        score.put("数学",90);
        score.put("英语",100);
        score.forEach((key,value)-> System.out.println(key+"->"+value));

输出：

语文->80

数学->90

英语->100

WeakHashMap类：如果该对象的key所引用的对象没有其他强引用变量所引用，则key所引用的对象可能会被垃圾回收

例子：

 WeakHashMap weakHashMap=new WeakHashMap();
        weakHashMap.put("语文","良好");
        weakHashMap.put("数学","优秀");
        weakHashMap.put("英语","优秀");
        System.out.println(weakHashMap);
        System.gc();
        System.runFinalization();
        System.out.println("test1:"+weakHashMap);

        WeakHashMap w=new WeakHashMap();
        w.put(new String("chinese"),85);
        w.put(new String("english"),90);
        w.put(new String("match"),95);
        System.out.println(w);
        System.gc();
        System.runFinalization();
        System.out.println("test2:"+w);

输出：{数学=优秀, 英语=优秀, 语文=良好}
test1:{数学=优秀, 英语=优秀, 语文=良好}
{chinese=85, english=90, match=95}
test2:{}

test1不被回收因为字符串在常量池里面，不会被垃圾回收，只会回收堆内的数据

泛型：

不论泛型的类型形参传入哪一种类型实参，总是被当做同一个类处理

List<String> list=new ArrayList<>();
        List<Integer> list1=new ArrayList<>();
        System.out.println(list.getClass()==list1.getClass());

运行结果：true

java讲义 枚举 弱引用 集合 ArrayDeque

猜你喜欢

java讲义枚举弱引用集合 ArrayDeque