Collection_Other

时间:2022-09-18 21:56:40
package com.bjsxt.others.que;

import java.util.ArrayDeque;
import java.util.Queue; /**
* 使用队列模拟银行存款业务
* @author Administrator
*
*/
public class Demo01 { /**
* @param args
*/
public static void main(String[] args) {
Queue<Request> que =new ArrayDeque<Request>();
//模拟排队情况
for(int i=0;i<10;i++){
final int num =i;
que.offer(new Request(){ @Override
public void deposit() {
System.out.println("第"+num+"个人,办理存款业务,存款额度为:"+(Math.random()*10000));
} });
} dealWith(que);
}
//处理业务
public static void dealWith(Queue<Request> que){
Request req =null;
while(null!=(req=que.poll())){
req.deposit();
}
} }
interface Request{
//存款
void deposit();
}

堆栈相关:

package com.bjsxt.others.que;

import java.util.ArrayDeque;
import java.util.Deque; /**
* 使用队列实现自定义堆栈
* 1、弹
* 2、压
* 3、获取头
* @author Administrator
*
* @param <E>
*/
public class MyStack<E> {
//容器
private Deque<E> container =new ArrayDeque<E>();
//容量
private int cap;
public MyStack(int cap) {
super();
this.cap = cap;
} //压栈
public boolean push(E e){
if(container.size()+1>cap){
return false;
}
return container.offerLast(e); }
//弹栈
public E pop(){
return container.pollLast();
}
//获取
public E peek(){
return container.peekLast();
} public int size(){
return this.container.size();
}
}

Demo:

package com.bjsxt.others.que;
//测试自定义堆栈
public class Demo02 { /**
* @param args
*/
public static void main(String[] args) {
MyStack<String> backHistory =new MyStack<String>(3);
backHistory.push("www.baidu.com");
backHistory.push("www.google.com");
backHistory.push("www.sina.com");
backHistory.push("www.bjsxt.cn"); System.out.println("大小:"+backHistory.size()); //遍历
String item=null;
while(null!=(item=backHistory.pop())){
System.out.println(item);
}
} }

Enumeration:

package com.bjsxt.others.en;

import java.util.Enumeration;
import java.util.Vector; /**
* Enumeration 的使用
* 1、判断 hasMoreElements()
* 2、获取 nextElement()
*
* Vector 的 elements()方法
*
*
* @author Administrator
*
*/
public class Demo01 { /**
* @param args
*/
public static void main(String[] args) {
Vector<String> vector =new Vector<String>();
vector.add("javase");
vector.add("html");
vector.add("oracle"); //遍历该Vector
Enumeration<String> en =vector.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
} } }
package com.bjsxt.others.en;

import java.util.StringTokenizer;

/**
* Enumeration 子类
* StringTokenizer:String split() 字符串分割
* 不支持正则表达式
*
* StringTokenizer(String str, String delim) * @author Administrator
*
*/
public class Demo02 { /**
* @param args
*/
public static void main(String[] args) {
String emailStr="bjsxt@163.com;bjsxt@qq.com;bjsxt@sohu.com";
StringTokenizer token =new StringTokenizer(emailStr,";");
//遍历获取
while(token.hasMoreElements()){
System.out.println(token.nextElement());
}
} }

HashMap与Hashtable的区别:

HashTable的应用非常广泛,HashMap是新框架中用来代替HashTable的类,也就是说建议使用HashMap,不要使用HashTable。可能你觉得HashTable很好用,为什么不用呢?这里简单分析他们的区别。
1.HashTable的方法是同步的,HashMap未经同步,所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。
2.HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。
3.HashTable有一个contains(Object value),功能和containsValue(Object value)功能一样。
4.HashTable使用Enumeration,HashMap使用Iterator。
以上只是表面的不同,它们的实现也有很大的不同。
5.HashTable中hash数组默认大小是11,增加的方式是 old*2+1。HashMap中hash数组的默认大小是16,而且一定是2的指数。
6.哈希值的使用不同,HashTable直接使用对象的hashCode,代码是这样的:
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;

Java中Vector和ArrayList的区别

首先看这两类都实现List接口,而List接口一共有三个实现类,分别是ArrayList、Vector和LinkedList。List用于存放多个元素,能够维护元素的次序,并且允许元素的重复。3个具体实现类的相关区别如下:

  1. ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔,当数组大小不满足时需要增加存储能力,就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动、代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。
  2. Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够写Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,因此,访问它比访问ArrayList慢。
  3. LinkedList是用链表结构存储数据的,很适合数据的动态插入和删除,随机访问和遍历速度比较慢。另外,他还提供了List接口中没有定义的方法,专门用于操作表头和表尾元素,可以当作堆栈、队列和双向队列使用。

查看Java源代码,发现当数组的大小不够的时候,需要重新建立数组,然后将元素拷贝到新的数组内,ArrayList和Vector的扩展数组的大小不同。

public boolean add(E e) {

    ensureCapacity(size + 1);  // 增加元素,判断是否能够容纳。不能的话就要新建数组

    elementData[size++] = e;

    return true;

}

 public void ensureCapacity(int minCapacity) {

    modCount++; 

    int oldCapacity = elementData.length;

    if (minCapacity > oldCapacity) {

        Object oldData[] = elementData; // 此行没看出来用处,不知道开发者出于什么考虑

        int newCapacity = (oldCapacity * 3)/2 + 1; // 增加新的数组的大小

        if (newCapacity < minCapacity)

       newCapacity = minCapacity;

            // minCapacity is usually close to size, so this is a win:

            elementData = Arrays.copyOf(elementData, newCapacity);

    }

}

Vector中:

private void ensureCapacityHelper(int minCapacity) {

    int oldCapacity = elementData.length;

    if (minCapacity > oldCapacity) {

        Object[] oldData = elementData;

        int newCapacity = (capacityIncrement > 0) ?

       (oldCapacity + capacityIncrement) : (oldCapacity * 2);

        if (newCapacity < minCapacity) {

       newCapacity = minCapacity;

        }

         elementData = Arrays.copyOf(elementData, newCapacity);

    }

}

Property:

package com.bjsxt.others.pro;

import java.util.Properties;

/**
* Properties 资源配置文件的读写
* 1、key 与value 只能为字符串
* 2、存储与读取
* setProperty(String key, String value)
* getProperty(String key, String defaultValue)
* @author Administrator
*
*/
public class Demo01 { /**
* @param args
*/
public static void main(String[] args) {
//创建对象
Properties pro =new Properties();
//存储
pro.setProperty("driver", "oracle.jdbc.driver.OracleDriver");
//pro.setProperty("url", "jdbc:oracle:thin:@localhost:1521:orcl");
pro.setProperty("user", "scott");
pro.setProperty("pwd", "tiger"); //获取
String url =pro.getProperty("url","test");
System.out.println(url);
} }
package com.bjsxt.others.pro;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties; /**
* 使用Properties 输出到文件
* 资源配置文件:
*
* 1、.properties
* store(OutputStream out, String comments)
store(Writer writer, String comments)
2、.xml
storeToXML(OutputStream os, String comment) :UTF-8字符集
storeToXML(OutputStream os, String comment, String encoding) * @author Administrator
*
*/
public class Demo02 { /**
* @param args
* @throws IOException
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException, IOException {
//创建对象
Properties pro =new Properties();
//存储
pro.setProperty("driver", "oracle.jdbc.driver.OracleDriver");
pro.setProperty("url", "jdbc:oracle:thin:@localhost:1521:orcl");
pro.setProperty("user", "scott");
pro.setProperty("pwd", "tiger"); //存储到e:/others 绝对路径 盘符:
//pro.store(new FileOutputStream(new File("e:/others/db.properties")), "db配置");
//pro.storeToXML(new FileOutputStream(new File("e:/others/db.xml")), "db配置");
//使用相对路径 当前的工程
// pro.store(new FileOutputStream(new File("db.properties")), "db配置");
// pro.store(new FileOutputStream(new File("src/db.properties")), "db配置");
pro.store(new FileOutputStream(new File("src/com/bjsxt/others/pro/db.properties")), "db配置");
} }

读取:

package com.bjsxt.others.pro;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties; /**
* 使用Properties读取配置文件
* 资源配置文件:
* 使用相对与绝对路径读取
* load(InputStream inStream)
load(Reader reader)
loadFromXML(InputStream in)
* @author Administrator
*
*/
public class Demo03 { /**
* @param args
* @throws IOException
* @throws FileNotFoundException
*/
public static void main(String[] args) throws FileNotFoundException, IOException {
Properties pro=new Properties();
//读取 绝对路径
//pro.load(new FileReader("e:/others/db.properties"));
//读取 相对路径
pro.load(new FileReader("src/com/bjsxt/others/pro/db.properties"));
System.out.println(pro.getProperty("user", "bjsxt"));
} }
package com.bjsxt.others.pro;

import java.io.IOException;
import java.util.Properties; /**
* 使用类相对路径读取配置文件
* bin
* @author Administrator
*
*/
public class Demo04 { /**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Properties pro =new Properties();
//类相对路径的 / bin
//pro.load(Demo04.class.getResourceAsStream("/com/bjsxt/others/pro/db.properties"));
//"" bin
pro.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("com/bjsxt/others/pro/db.properties"));
System.out.println(pro.getProperty("user", "bjsxt"));
} }

java 引用分类(摘抄)

在 jdk 1.2 及其以后,引入了强引用、软引用、弱引用、虚引用这四个概念。网上很多关于这四个概念的解释,但大多是概念性的泛泛而谈,今天我结合着代码分析了一下,首先我们先来看定义与大概解释(引用类型在包 java.lang.ref 里)。

1、强引用(StrongReference)

    强引用不会被GC回收,并且在java.lang.ref里也没有实际的对应类型。举个例子来说:
    Object obj = new Object();
    这里的obj引用便是一个强引用,不会被GC回收。

2、软引用(SoftReference)

    软引用在JVM报告内存不足的时候才会被GC回收,否则不会回收,正是由于这种特性软引用在caching和pooling中用处广泛。软引用的用法:

Object obj = new Object();

SoftReference<Object> softRef = new SoftReference(obj);

// 使用 softRef.get() 获取软引用所引用的对象

Object objg = softRef.get();

3、弱引用(WeakReference)

    当GC一但发现了弱引用对象,将会释放WeakReference所引用的对象。弱引用使用方法与软引用类似,但回收策略不同。

4、虚引用(PhantomReference)

    当GC一但发现了虚引用对象,将会将PhantomReference对象插入ReferenceQueue队列,而此时 PhantomReference所指向的对象并没有被GC回收,而是要等到ReferenceQueue被你真正的处理后才会被回收。虚引用的用法:

Object obj = new Object();

ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();

PhantomReference<Object> phanRef = new PhantomReference<Object>(obj, refQueue);

// 调用phanRef.get()不管在什么情况下会一直返回null

Object objg = phanRef.get();

// 如果obj被置为null,当GC发现了虚引用,GC会将phanRef插入进我们之前创建时传入的refQueue队列

// 注意,此时phanRef所引用的obj对象,并没有被GC回收,在我们显式地调用refQueue.poll返回phanRef之后

// 当GC第二次发现虚引用,而此时JVM将phanRef插入到refQueue会插入失败,此时GC才会对obj进行回收

Reference<? extends Object> phanRefP = refQueue.poll();

看了简单的定义之后,我们结合着代码来测试一下,强引用就不用说了,软引用的描述也很清楚,关键是 “弱引用” 与 “虚引用”。

弱引用

public static void main(String[] args) throws InterruptedException {

Object obj = new Object();

ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();

WeakReference<Object> weakRef = new WeakReference<Object>(obj, refQueue);

System.out.println(weakRef.get());

System.out.println(refQueue.poll());

obj = null;

System.gc();

System.out.println(weakRef.get());

System.out.println(refQueue.poll());

}

由于System.gc()是告诉JVM这是一个执行GC的好时机,但具体执不执行由JVM决定,因此当JVM决定执行GC,得到的结果便是(事实上这段代码一般都会执行GC):

java.lang.Object@de6ced
  null
  null
java.lang.ref.WeakReference@1fb8ee3

从执行结果得知,通过调用weakRef.get()我们得到了obj对象,由于没有执行GC,因此refQueue.poll()返回的 null,当我们把obj = null;此时没有引用指向堆中的obj对象了,这里JVM执行了一次GC,我们通过weakRef.get()发现返回了null,而 refQueue.poll()返回了WeakReference对象,因此JVM在对obj进行了回收之后,才将weakRef插入到refQueue 队列中。

虚引用

public static void main(String[] args) throws InterruptedException {

Object obj = new Object();

ReferenceQueue<Object> refQueue = new ReferenceQueue<Object>();

PhantomReference<Object> phanRef = new PhantomReference<Object>(obj, refQueue);

System.out.println(phanRef.get());

System.out.println(refQueue.poll());

obj = null;

System.gc();

System.out.println(phanRef.get());

System.out.println(refQueue.poll());

}

同样,当JVM执行了GC,得到的结果便是:

  null
  null
  null
java.lang.ref.PhantomReference@1fb8ee3

从执行结果得知,我们先前说的没有错,phanRef.get()不管在什么情况下,都会返回null,而当JVM执行GC发现虚引用之后,JVM 并没有回收obj,而是将PhantomReference对象插入到对应的虚引用队列refQueue中,当调用refQueue.poll()返回 PhantomReference对象时,poll方法会先把PhantomReference的持有队列 queue(ReferenceQueue<? super T>)置为NULL,NULL对象继承自ReferenceQueue,将enqueue(Reference paramReference)方法覆盖为return false,而此时obj再次被GC发现时,JVM再将PhantomReference插入到NULL队列中便会插入失败返回false,此时GC便会回收obj。事实上通过这段代码我们也的却看不出来obj是否被回收,但通过 PhantomReference 的javadoc注释中有一句是这样写的:

Once the garbage collector decides that an object obj is phantom-reachable, it is being enqueued on the corresponding queue, but its referent is not cleared. That is, the reference queue of the phantom reference must explicitly be processed by some application code.

翻译一下(这句话很简单,我相信很多人应该也看得懂):

一旦GC决定一个“obj”是虚可达的,它(指PhantomReference)将会被入队到对应的队列,但是它的指代并没有被清除。也就是说,虚引用的引用队列一定要明确地被一些应用程序代码所处理。

弱引用与虚引用的用处

  软引用很明显可以用来制作caching和pooling,而弱引用与虚引用呢?其实用处也很大,首先我们来看看弱引用,举个例子:

class Registry {

private Set registeredObjects = new HashSet();

public void register(Object object) {

registeredObjects.add( object );

}

}

所有我添加进 registeredObjects 中的object永远不会被GC回收,因为这里有个强引用保存在registeredObjects里,另一方面如果我把代码改为如下:

class Registry {

private Set registeredObjects = new HashSet();

public void register(Object object) {

registeredObjects.add( new WeakReference(object) );

}

}

现在如果GC想要回收registeredObjects中的object,便能够实现了,同样在使用HashMap如果想实现如上的效果,一种更好的实现是使用WeakHashMap。

而虚引用呢?我们先来看看javadoc的部分说明:

Phantom references are useful for implementing cleanup operations that are necessary before an object gets garbage-collected. They are sometimes more flexible than the finalize() method.

翻译一下:

虚引用在实现一个对象被回收之前必须做清理操作是很有用的。有时候,他们比finalize()方法更灵活。

很明显的,虚引用可以用来做对象被回收之前的清理工作。

package com.bjsxt.others.three;

import java.lang.ref.WeakReference;

/**
* 引用分类:强、软、弱、虚
* 强与弱引用
* @author Administrator
*
*/
public class RefDemo { /**
* @param args
*/
public static void main(String[] args) {
//字符串常量池
String str =new String("bjsxt is very good");
//弱引用 管理 对象
WeakReference<String> wr =new WeakReference<String>(str);
System.out.println("gc运行前:"+wr.get());
//断开引用
str =null;
//通知回收
System.gc();
System.runFinalization();
//对象被回收
System.out.println("gc运行后:"+wr.get());
}
public static void testStrong(){
//字符串常量池 共享(不能回收)
String str ="bjsxt is very good";
//弱引用 管理 对象
WeakReference<String> wr =new WeakReference<String>(str);
System.out.println("gc运行前:"+wr.get());
//断开引用
str =null;
//通知回收
System.gc();
System.runFinalization();
System.out.println("gc运行后:"+wr.get());
} }
package com.bjsxt.others.three;

import java.util.WeakHashMap;

/**
* WeakHashMap 键为弱类型,gc运行立即回收
* @author Administrator
*
*/
public class WeakHashMapDemo { /**
* @param args
*/
public static void main(String[] args) {
WeakHashMap<String,String> map =new WeakHashMap<String,String>();
//测试数据
//常量池对象,不会回收
map.put("abc", "a");
map.put("d", "test");
//gc运行 已被回收
map.put(new String("bjsxt"), "c");
map.put(new String("dsf"), "d"); //通知回收
System.gc();
System.runFinalization(); System.out.println(map.size());
} }
package com.bjsxt.others.three;

import java.util.IdentityHashMap;

/**
* IdentityHashMap 键比较地址去重
* @author Administrator
*
*/
public class IdentityHashMapDemo { /**
* @param args
*/
public static void main(String[] args) {
IdentityHashMap<String ,String> map =new IdentityHashMap<String,String>();
//常量池中的"a"
map.put("a", "a1");
map.put("a", "a2");
System.out.println(map.size());
map.put(new String("a"), "a3");
map.put(new String("a"), "a4");
System.out.println(map.size()); } }
package com.bjsxt.others.three;

import java.util.EnumMap;

/**
* EnumMap要求键为枚举
* @author Administrator
*
*/
public class EnumMapDemo { /**
* @param args
*/
public static void main(String[] args) {
EnumMap<Season,String> map =new EnumMap<Season,String>(Season.class);
//存放值
map.put(Season.SPRING, "春困");
map.put(Season.SUMMER, "夏无力");
map.put(Season.AUTUMN, "秋乏");
map.put(Season.WINTER, "冬眠"); System.out.println(map.size()); } }
//季节
enum Season{
SPRING,SUMMER,AUTUMN,WINTER
}
package com.bjsxt.others.synread;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List; /**
* 使用Collections管理同步 容器
* synchronizedList()
synchronizedSet()
synchronizedMap() * @author Administrator
*
*/
public class Demo01 { /**
* @param args
*/
public static void main(String[] args) {
List<String> list =new ArrayList<String>();
list.add("a");
list.add("b");
//list可以同步
List<String> synList =Collections.synchronizedList(list);
System.out.println("线程安全的list制作完毕");
} }
package com.bjsxt.others.synread;

import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set; /**
* 只读设置
* emptyXxx() 空的不可变的集合
* 1、emptyList()
* emptyMap()
* emptySet()
2、singletonXxx() 一个元素不可变的集合
singleton(T o)
singletonList(T o)
singletonMap(K key, V value) 3、unmodifiableXxx() 不可变容器
unmodifiableList(List<? extends T> list)
unmodifiableSet(Set<? extends T> s)
unmodifiableMap(Map<? extends K,? extends V> m)
* @author Administrator
*
*/
public class Demo02 { /**
* @param args
*/
public static void main(String[] args) {
Map<String,String> map =new HashMap<String,String>(); map.put("test", "test");
map.put("bjsxt", "bjsxt"); //只读控制
Map<String,String> map2 =Collections.unmodifiableMap(map);
//map2.put("a", "a"); //不能操作
System.out.println(map2.size()); //一个元素的容器测试
List<String> list =Collections.singletonList(new String());
list.add("test");
//list.add("bjsxt"); //只能包含一个元素的容器
} public static Set<String> oper(Set<String> set){
if(null==set){
return Collections.EMPTY_SET; //外部获取避免NullPointerException
}
//操作
return set;
} }

Collection_Other的更多相关文章

    随机推荐

    1. 【分布式】Zookeeper服务端启动

      一.前言 前面已经了解了Zookeeper会话相关知识点,接着来学习Zookeeper服务端相关细节. 二.服务端 服务端整体架构如下 Zookeeper服务器的启动,大致可以分为以下五个步骤 1. ...

    2. Android 透明Button

      1.是制作9-patch的图片,这样能够匹配文字内容的长短. 2.是指定按钮样式背景,即定制drawable的xml文件,这样做的好处不用图片做背景,节省空间. 定制透明样式的按钮.直接看代码: dr ...

    3. (转)open和fopen的区别:

      fopen与open的区别 open和fopen的区别: 1.缓冲文件系统缓冲文件系统的特点是:在内存开辟一个“缓冲区”,为程序中的每一个文件使用,当执行读文件的操作时,从磁盘文件将数据先读入内存“缓 ...

    4. Find the largest multiple of 3 解答

      Question Given an array of non-negative integers. Find the largest multiple of 3 that can be formed ...

    5. HTML5 技术在风电、光伏等新能源领域的应用

      随着新一轮工业革命兴起,应对气候变化日益成为全球共识,能源技术正在成为引领能源产业变革.实现创新驱动发展的源动力.从全球到中国,以风能.光伏发电为代表的新能源产业发展迅速,可再生能源发电与现代电网的融 ...

    6. PowerBI

      1.官方PowerBI实例:https://docs.microsoft.com/zh-cn/power-bi/sample-tutorial-connect-to-the-samples 2.配置计 ...

    7. Nginx的使用(三)把nginx和php-cgi&period;exe注册成windows服务

      1.创建windows服务用到一个小工具WinSW:https://github.com/kohsuke/winsw/releases(下载 .exe 文件即可,根据系统选择,Win 10 选择 .N ...

    8. python、java大作战,python测试dubbo接口

      很多小伙伴都反映公司要求测dubbo(dubbo是一个java的分布式开源框架)接口,不会写java代码,怎么测,能不能用python来调dubbo接口.当然是可以的了,最近研究了一下,很简单,分享给 ...

    9. ubuntu16&period;04&plus;opencv3&period;0&period;0

      基本步骤: http://blog.csdn.net/xuezhisdc/article/details/48691797 报错: http://www.jianshu.com/p/68ac83436 ...

    10. 图解linux内核编译框架

      内核是如何编译成的 -知其然而不知其所以然 (第一篇) 转载:http://blog.chinaunix.net/uid-28236237-id-3840137.html Linux内核有分门别类的目 ...

    相关文章