Thinking in Java 中闪耀的星星(三)

古城微笑少年丶 2022-09-25 13:22 3阅读 0赞

41.容器集合的选择  
List容器无非分为两大种，基于数组和基于链表：数组有索引，所以查找快，链表插入删除不需要移动全部元素，插入删除快。  
ArrayList/Vector查找快，LinkedList插入删除元素快。而Queue什么都快，但是队列先入先出，没有其他集合灵活。  
Set也是大体分为两种，基于红黑树的Tree和基于hash算法的Hash（Set的元素是不能重复的，List可以重复）。  
HashSet各方面的速度稍微比TreeSet快。但TreeSet元素的排列是经过排序的。  
Map的情况与set类似（HashMap和TreeMap），一般来讲，程序选择基于Hash的多。  
42.回收容器元素的引用  
如果遇到容器过于庞大或者硬件配置太低而需要回收元素的地址，可以选择使用更加利于回收机制的容器。SoftReference，weakReference，PhantomReference。  
具体用法看下面的例子：

import java.lang.ref.*;
    import java.util.*;
    class VeryBig{
        private static final int SIZE=10000;
        private long[] la=new long[SIZE];
        private String ident;
        public VeryBig(String id){ident=id;}
        public String toString(){
       return ident;}
        protected void finalize(){System.out.println("Finalizing"+ident);}
    }
    public class References{
        private static ReferenceQueue<VeryBig> rq=new ReferenceQueue<VeryBig>();
        public static void checkQueue(){
            Reference<? extends VeryBig> inq=rq.poll();
            if(inq!=null)
                System.out.println("In queue:"+ inq.get());
        }
        public static void main(String[] args){
            int size=10;
            if(args.length>0)
                size=new Integer(args[0]);
            LinkedList<SoftReference<VeryBig>> sa=new LinkedList<SoftReference<VeryBig>>();
            for(int i=0;i<size;i++){
                sa.add(new SoftReference<VeryBig>(new VeryBig("Soft "+i),rq));
                System.out.println("Just created:"+sa.getLast());
                checkQueue();
            }
            LinkedList<WeakReference<VeryBig>> wa=new LinkedList<WeakReference<VeryBig>>();
            for(int i=0;i<size;i++){
                wa.add(new WeakReference<VeryBig>(new VeryBig("weak "+i),rq));
                System.out.println("Just created:"+wa.getLast());
                checkQueue();
            }
            SoftReference<VeryBig> s=new SoftReference<VeryBig>(new VeryBig("Soft"));
            WeakReference<VeryBig> w=new WeakReference<VeryBig>(new VeryBig("Weak"));
            System.gc();
            LinkedList<PhantomReference<VeryBig>> pa=new LinkedList<PhantomReference<VeryBig>>();
            for(int i=0;i<size;i++){
                pa.add(new PhantomReference<VeryBig>(new VeryBig("Phantom "+i),rq));
                System.out.println("Just created:"+pa.getLast());
                checkQueue();
            }
        }
    }/*Output Just created:java.lang.ref.SoftReference@76ea7776 Just created:java.lang.ref.SoftReference@1b4920f8 Just created:java.lang.ref.SoftReference@5e1387c6 Just created:java.lang.ref.SoftReference@5437086a Just created:java.lang.ref.SoftReference@69099257 Just created:java.lang.ref.SoftReference@7366c3a0 Just created:java.lang.ref.SoftReference@5fb57890 Just created:java.lang.ref.SoftReference@2fe6707 Just created:java.lang.ref.SoftReference@c1dfe1a Just created:java.lang.ref.SoftReference@515632d Just created:java.lang.ref.WeakReference@3f2221f6 Just created:java.lang.ref.WeakReference@59e3bddb Just created:java.lang.ref.WeakReference@76c5a2f7 Just created:java.lang.ref.WeakReference@294e430c Just created:java.lang.ref.WeakReference@5113de03 Just created:java.lang.ref.WeakReference@6f54c08a Just created:java.lang.ref.WeakReference@252cdd20 Just created:java.lang.ref.WeakReference@246972f1 Just created:java.lang.ref.WeakReference@6f93ee4 Just created:java.lang.ref.WeakReference@558fee4f Just created:java.lang.ref.PhantomReference@2f995c9a In queue:null FinalizingWeak Just created:java.lang.ref.PhantomReference@7d8e9adf In queue:null Finalizingweak 9 Finalizingweak 8 Finalizingweak 7 Finalizingweak 6 Finalizingweak 5 Finalizingweak 4 Finalizingweak 3 Finalizingweak 2 Finalizingweak 1 Finalizingweak 0 Just created:java.lang.ref.PhantomReference@1d59e6df In queue:null Just created:java.lang.ref.PhantomReference@79444986 In queue:null Just created:java.lang.ref.PhantomReference@72373a9c In queue:null Just created:java.lang.ref.PhantomReference@7e91259 In queue:null Just created:java.lang.ref.PhantomReference@56b3951d In queue:null Just created:java.lang.ref.PhantomReference@2802cf63 In queue:null Just created:java.lang.ref.PhantomReference@507d811a In queue:null Just created:java.lang.ref.PhantomReference@5fa6fb3e In queue:null *///~

43.Collection的特性  
Collection为List，Set，Queue的始祖，有一些不错的特性，比如翻转元素，替换元素，移动元素…  
看例子吧：

import java.util.*;
    public class Utilities{
        static List<String> list=Arrays.asList("one two three Four five six one".split(" "));
        public static void main(String[] args){
            System.out.println(list);
            System.out.println("'list' disjoint (Four)?:"+Collections.disjoint(list,Collections.singletonList("Four")));
            System.out.println("max: "+Collections.max(list));
            System.out.println("min: "+Collections.min(list));
            System.out.println("max a/ comparator: "+Collections.max(list,String.CASE_INSENSITIVE_ORDER));
            System.out.println("min a/ comparator: "+Collections.min(list,String.CASE_INSENSITIVE_ORDER));
            List<String> sublist=Arrays.asList("Four five six".split(" "));
            System.out.println("indexOfSubList: "+Collections.indexOfSubList(list,sublist));
            System.out.println("lastIndexofList: "+Collections.lastIndexOfSubList(list,sublist));
            Collections.replaceAll(list,"one","Yo");
            System.out.println("replaceAll: "+list);
            Collections.reverse(list);
            System.out.println("reverse: "+list);
            Collections.rotate(list,3);
            System.out.println("rotate: "+list);
            List<String> source=Arrays.asList("in the matrix".split(" "));
            Collections.copy(list,source);
            System.out.println("copy: "+list);
            Collections.swap(list,0,list.size()-1);
            System.out.println("swap: "+list);
            Collections.shuffle(list,new Random(47));
            System.out.println("shuffled: "+list);
            Collections.fill(list,"pop");
            System.out.println("fill: "+list);
            System.out.println("frequency of 'pop': "+Collections.frequency(list,"pop"));
            List<String> dups=Collections.nCopies(3,"snap");
            System.out.println("dups: "+dups);
            System.out.println("'list' disjoint 'dups'?: "+Collections.disjoint(list,dups));
            Enumeration<String> e=Collections.enumeration(dups);
            Vector<String> v=new Vector<String>();
            while(e.hasMoreElements())
                v.addElement(e.nextElement());
            ArrayList<String> arrayList=Collections.list(v.elements());
            System.out.println("arrayList: "+arrayList);
        }
    }/*Output [one, two, three, Four, five, six, one] 'list' disjoint (Four)?:false max: two min: Four max a/ comparator: two min a/ comparator: five indexOfSubList: 3 lastIndexofList: 3 replaceAll: [Yo, two, three, Four, five, six, Yo] reverse: [Yo, six, five, Four, three, two, Yo] rotate: [three, two, Yo, Yo, six, five, Four] copy: [in, the, matrix, Yo, six, five, Four] swap: [Four, the, matrix, Yo, six, five, in] shuffled: [six, matrix, the, Four, Yo, five, in] fill: [pop, pop, pop, pop, pop, pop, pop] frequency of 'pop': 7 dups: [snap, snap, snap] 'list' disjoint 'dups'?: true arrayList: [snap, snap, snap] *///~

43.重写hashCode()方法  
为什么要重写hashCode()：如果现有的集合满足不了你，想自己写一个或者修改现有集合，就必须要重写hashCode()，因为像Map的key都要有一个hashCode()。  
看代码，理解思路就好：

import java.util.*;
    public class CountedString{
        private static List<String> created=new ArrayList<String>();
        private String s;
        private int id=0;
        public CountedString(String str){
            s=str;
            created.add(s);
            for(String s2 : created)
                if(s2.equals(s))
                    id++;
        }
        public String toString(){
            return "String:"+s+"id:"+id+"hasCode():"+hashCode();
        }
        public int hashCode(){
            int result=17;
            result=37*result+s.hashCode();
            result=37*result+id;
            return result;
        }
        public boolean equals(Object o){
            return o instanceof CountedString && s.equals(((CountedString)o).s)&&id==((CountedString)o).id;
        }
        public static void main(String[] args){
            Map<CountedString,Integer> map=new HashMap<CountedString,Integer>();
            CountedString[] cs=new CountedString[5];
            for(int i=0;i<cs.length;i++){
                cs[i]=new CountedString("hi");
                map.put(cs[i],i);
            }
            System.out.println(map);
            for(CountedString cstring:cs){
                System.out.println("Looking up"+cstring);
                System.out.println(map.get(cstring));
            }
        }
    }/*Output {String:hiid:1hasCode():146447=0, String:hiid:2hasCode():146448=1, String:hiid:3hasCode():146449=2, String:hiid:4hasCode():146450=3, String:hiid:5hasCode():146451=4} Looking upString:hiid:1hasCode():146447 0 Looking upString:hiid:2hasCode():146448 1 Looking upString:hiid:3hasCode():146449 2 Looking upString:hiid:4hasCode():146450 3 Looking upString:hiid:5hasCode():146451 4 *///~

44.如何把类写成只读形式  
final关键字：

public class Pair<K,V>{
           public final K key;
           public final V value;
           public Pair(K k,V v){
                key=k;
                value=v;
           }
    }

45.Map的底层实现  
Map其实是基于List的，看代码吧：

import java.util.*;
    public class SlowMap<K,V> extends AbstractMap<K,V>{
        private List<K> keys=new ArrayList<K>();
        private List<V> values=new ArrayList<V>();
        public V put(K key,V value){
            V oldValue=get(key);
            if(!key.contains(key)){
                keys.add(key);
                values.add(value);
            }else{
                values.set(keys.indexOf(key).value);
            }
            return oldValue;
        }
        public V get(Object key){
            if(!keys.contains(key))
               return null;
            return values.get(keys.indexOf(key));
        }
        public Set<Map.Entry<K,V>> entrySet(){
            Set<Map.Entry<K,V>> set=new HashSet<Map.Entry<K,V>>();
            Iterator<K> ki=keys.iterator();
            iterator<V> vi=values.iterator();
            while(ki.hasNext())
               set.add(new MapEntry<K,V>(ki.next(),vi.next()));
            return set;
        }
        public static void main(String[] args){
            SlowMap<String,String> m=new SlowMap<String,String>();
            m.putAll(Countries.capitals(15));
            System.out.println(m);
            System.out.println(m.get('BULGARIA')); 
            System.out.println(m.entrySet()); 
        }
    }/*Output *///~

46.io流反映基本类型的长度  
在书上有个蛮有趣的demo，io流把byte转化为其他基本类型的：

import java.nio.*;
    public class ViewBuffers{
        public static void main(String[] args){
            ByteBuffer bb=ByteBuffer.wrap(
                new byte[]{
       0,0,0,0,0,0,0,'a'});
            bb.rewind();
            System.out.println("Byte Buffer");
            while(bb.hasRemaining())
                System.out.print(bb.position()+" ->"+bb.get()+", ");
            System.out.println();
            CharBuffer cb=((ByteBuffer)bb.rewind()).asCharBuffer();
            System.out.println("Char Buffer");
            while(cb.hasRemaining())
                System.out.print(cb.position()+" ->"+cb.get()+", ");
            System.out.println();
            FloatBuffer fb=((ByteBuffer)bb.rewind()).asFloatBuffer();
            System.out.println("Float Buffer");
            while(fb.hasRemaining())
                System.out.print(fb.position()+" ->"+fb.get()+", ");
            System.out.println();
            IntBuffer ib=((ByteBuffer)bb.rewind()).asIntBuffer();
            System.out.println("Int Buffer");
            while(ib.hasRemaining())
                System.out.print(ib.position()+" ->"+ib.get()+", ");
            System.out.println();
            LongBuffer lb=((ByteBuffer)bb.rewind()).asLongBuffer();
            System.out.println("Long Buffer");
            while(lb.hasRemaining())
                System.out.print(lb.position()+" ->"+lb.get()+", ");
            System.out.println();
            ShortBuffer sb=((ByteBuffer)bb.rewind()).asShortBuffer();
            System.out.println("Short Buffer");
            while(sb.hasRemaining())
                System.out.print(sb.position()+" ->"+sb.get()+", ");
            System.out.println();
            DoubleBuffer db=((ByteBuffer)bb.rewind()).asDoubleBuffer();
            System.out.println("Double Buffer");
            while(db.hasRemaining())
                System.out.print(db.position()+" ->"+db.get()+", ");
            System.out.println();
        }
    }/*Output har Buffer 0 ->, 1 ->, 2 ->, 3 ->a, Float Buffer 0 ->0.0, 1 ->1.36E-43, Int Buffer 0 ->0, 1 ->97, Long Buffer 0 ->97, Short Buffer 0 ->0, 1 ->0, 2 ->0, 3 ->97, Double Buffer 0 ->4.8E-322, *///~

47.io流不同类型读写文件的速度  
io流采用装饰者模式，层层装饰。java发展到现在，有”old” io 和”new” io。书里有个测试平台，基于模板方法模式写的，用来测试MappedIO和边准io流DataInputStream/DataOutputStream的速度，结果的比例是差不多的，但是时间根据硬件和操作系统会有所不同：

import java.io.*;
    import java.nio.*;
    import java.nio.channels.*;
    public class MappedIO{ 
        private static int numOfInts=4000000;
        private static int numOfUbuffInts=200000;
        private abstract static class Tester{ 
            private String name;
            public Tester(String name){
       this.name=name;}
            public void runTest(){
                System.out.println(name+": ");
                try{
                    long start=System.nanoTime();
                    test();
                    double duration=System.nanoTime()-start;
                    System.out.format("%.2f\n",duration/1.0e9);
                }catch(IOException e){
                    throw new RuntimeException(e);
                }
            }
            public abstract void test() throws IOException;
        }
        private static Tester[] tests={
            new Tester("Stream Write"){
                public void test() throws IOException{
                    DataOutputStream dos=new DataOutputStream(
                        new BufferedOutputStream(
                            new FileOutputStream(new File("temp.tmp"))));
                    for(int i=0;i<numOfInts;i++)
                        dos.writeInt(i);
                    dos.close();
                }
            },
            new Tester("Mapped Write"){
                 public void test() throws IOException{
                     FileChannel fc=new RandomAccessFile("temp.tmp","rw").getChannel();
                     IntBuffer ib=fc.map(FileChannel.MapMode.READ_WRITE,0,fc.size()).asIntBuffer(); 
                     for(int i=0;i<numOfInts;i++)
                         ib.put(i);
                     fc.close();        
                 }
            },
            new Tester("Stream Read"){
                 public void test() throws IOException{
                     DataInputStream dis=new DataInputStream(
                         new BufferedInputStream(
                             new FileInputStream("temp.tmp"))); 
                 for(int i=0;i<numOfInts;i++)
                     dis.readInt();
                 dis.close();  
                 }
            },
            new Tester("Mapped Read"){
                 public void test() throws IOException{
                     FileChannel fc=new FileInputStream(
                         new File("temp.tmp")).getChannel();
                     IntBuffer ib=fc.map(FileChannel.MapMode.READ_ONLY,0,fc.size()).asIntBuffer();
                     while(ib.hasRemaining())
                         ib.get();
                     fc.close();
                 }
            },
            new Tester("Stream Read/Write"){
                 public void test() throws IOException{
                     RandomAccessFile raf=new RandomAccessFile(
                         new File("temp.tmp"),"rw");
                     raf.writeInt(1);
                     for(int i=0;i<numOfUbuffInts;i++){
                         raf.seek(raf.length()-4);
                         raf.writeInt(raf.readInt());
                     }
                     raf.close();
                 }
            },
            new Tester("Mapped Read/Write"){
                 public void test() throws IOException{
                     FileChannel fc=new RandomAccessFile(
                         new File("temp.tmp"),"rw").getChannel();
                     IntBuffer ib=fc.map(FileChannel.MapMode.READ_WRITE,0,fc.size()).asIntBuffer();
                     ib.put(0);
                     for(int i=1;i<numOfUbuffInts;i++)
                         ib.put(ib.get(i-1));
                     fc.close();
                 }
            }
        };
        public static void main(String[] args){
            for(Tester test:tests)
                test.runTest();
        }
    }/*Output Stream Write: 0.92 Mapped Write: 0.05 Stream Read: 0.83 Mapped Read: 0.02 Stream Read/Write: 2.70 Mapped Read/Write: 0.03 *///~

48.文件锁  
对于一些共享文件，在多线程中需要保证一致性(类似与jdbc事务)或者不想文件被其他人访问，就需要对文件上锁。下面的例子是锁住部分文件内容的：

import java.nio.*;
    import java.nio.channels.*;
    import java.io.*;
    public class LockingMappedFiles{ 
        static final int LENGTH =0x8FFFFFF;//128M
        static FileChannel fc;
        public static void main(String[] args) throws IOException{
            fc=new RandomAccessFile("test.dat","rw").getChannel();
            MappedByteBuffer out=fc.map(FileChannel.MapMode.READ_WRITE,0,LENGTH);
            for(int i=0;i<LENGTH;i++)
                out.put((byte)'x');
            new LockAndModify(out,0,0+LENGTH/3);
            new LockAndModify(out,LENGTH/2,LENGTH/2+LENGTH/4); 
        }
        private static class LockAndModify extends Thread{ 
            private ByteBuffer buff;
            private int start,end;
            LockAndModify(ByteBuffer mbb,int start,int end){
                this.start=start;
                this.end=end;
                mbb.limit(end);
                mbb.position(start);
                buff=mbb.slice();
                start();
            }
            public void run(){
                try{
                    FileLock fl=fc.lock(start,end,false);
                    System.out.println("Locked: "+start+" to "+end);
                    while(buff.position()<buff.limit()-1)
                        buff.put((byte)(buff.get()+1));
                    fl.release();
                    System.out.println("Release: "+start+" to "+end);
                }catch(IOException e){
                    throw new RuntimeException(e);
                }
            }
        }
    }/*Output Locked: 0 to 50331647 Locked: 75497471 to 113246206 Release: 75497471 to 113246206 Release: 0 to 50331647 *///~

49.文件压缩  
io流可以将文件压缩，在网络传输中尤为重要，io流可以将文件压缩为GZIP,ZIP,Jar…  
1）.压缩为jar：  
jar cf myJarFile.jar \*.class //把该目录下所有的.class文件打包压缩进一个叫myJarFile.jar的jar包里面  
jar tf myJarFile.jar //打印出myJarFile.jar文件的所有子文件(.class)  
jar tvf myJarFile.jar //与上一句一样，多打印出 myJarFile.jar所有子文件的详细信息(日期，大小，用户等信息)  
2）.压缩为GZIP/ZIP，下面以GZIP为例

import java.util.zip.*;
    import java.io.*;
    public class GZIPcompress{
        public static void main(String[] args) throws IOException{
            if(args.length==0){
                System.out.println(
                    "Usage:\nGZIPcompress file\n"+
                    "\tUses GZIP compression to compress"+
                    "the file to test.gz");
            System.exit(1);
            }
            BufferedReader in=new BufferedReader(
                new FileReader(args[0]));
            BufferedOutputStream out=new BufferedOutputStream(
                new GZIPOutputStream(new FileOutputStream("test.gz")));
            System.out.println("Writing file");
            int c;
            while((c=in.read())!=-1)
                out.write(c);
            in.close();
            out.close();
            System.out.println("Reading file");
            BufferedReader in2=new BufferedReader(
                new InputStreamReader(new GZIPInputStream(
                    new FileInputStream("test.gz"))));
            String s;
            while((s=in2.readLine())!=null)
                System.out.println(s);
        }
    }

50.序列化  
io流在网络传输中的作用很重要，有些时候，为了减少创建类的开销加快传输速度，需要将对象转化为持久态(类似与J2EE中Hibernate的持久态session)。下面的例子是读取文件时将对象序列化，往后的对文件对该对象就可以直接操作：

import java.util.*;
    import java.io.*;
    class Data implements Serializable{
        private int n;
        public Data(int n){
       this.n=n;}
        public String toString(){
       return Integer.toString(n);}
    }
    public class Worm implements Serializable{ 
        private static Random rand=new Random(47);
        private Data[] d={
            new Data(rand.nextInt(10)),
            new Data(rand.nextInt(10)),
            new Data(rand.nextInt(10))
        };
        private Worm next;
        private char c;
        public Worm(int i,char x){
            System.out.println("Worm constructor: "+i);
            c=x;
            if(--i>0)
               next=new Worm(i,(char)(x+1));
        }
        public Worm(){
            System.out.println("Default constructor");
        }
        public String toString(){
            StringBuilder result=new StringBuilder(":");
            result.append(c);
            result.append("(");
            for(Data dat : d)
               result.append(dat);
            result.append(")");
            if(next!=null)
            result.append(next);
            return result.toString();
        } 
        public static void main(String[] args) throws ClassNotFoundException,IOException{
            Worm w=new Worm(6,'a');
            System.out.println("w= "+w);
            ObjectOutputStream out=new ObjectOutputStream(
                new FileOutputStream("worm.out"));
            out.writeObject("Worm storage\n");
            out.writeObject(w);
            out.close();
            ObjectInputStream in=new ObjectInputStream(
                new FileInputStream("worm.out"));
            String s=(String)in.readObject();
            Worm w2=(Worm)in.readObject();
            System.out.println(s+" w2= "+w2);
            ByteArrayOutputStream bout=new ByteArrayOutputStream();
            ObjectOutputStream out2=new ObjectOutputStream(bout);
            out2.writeObject("Worm storage\n");
            out2.writeObject(w);
            out2.flush();
            ObjectInputStream in2=new ObjectInputStream(
                new ByteArrayInputStream(bout.toByteArray()));
            s=(String)in2.readObject();
            Worm w3=(Worm)in2.readObject();
            System.out.println(s+" w3= "+w3);
        }   
    }/*Output Worm constructor: 6 Worm constructor: 5 Worm constructor: 4 Worm constructor: 3 Worm constructor: 2 Worm constructor: 1 w= :a(853):b(119):c(802):d(788):e(199):f(881) Worm storage w2= :a(853):b(119):c(802):d(788):e(199):f(881) Worm storage w3= :a(853):b(119):c(802):d(788):e(199):f(881) *///~
    但是一些时候，有些机密信息不想轻易被其他文件读取修改，可以通过transient关键字指明不被序列化，比如登录中的密码：
    import java.util.concurrent.*;
    import java.io.*;
    import java.util.*;
    public class Logon implements Serializable{ 
        private Date date=new Date();
        private String username;
        private transient String password;
        public Logon(String name,String pwd){
            username=name;
            password=pwd;
        }
        public String toString(){
            return "logon info: \n username: "+username+
                "\n date: "+date+"\n password: "+password;
        }
        public static void main(String[] args) throws Exception{
            Logon a=new Logon("Hulk","myLittlePony");
            System.out.println("Logon a="+a);
            ObjectOutputStream o=new ObjectOutputStream(
                new FileOutputStream("Logon.out"));
            o.writeObject(a);
            o.close();
            TimeUnit.SECONDS.sleep(1);
            ObjectInputStream in=new ObjectInputStream(
                new FileInputStream("Logon.out"));
            a=(Logon)in.readObject();
            System.out.println("Logon a="+a);
        }
    }/*Output Logon a=logon info: username: Hulk date: Mon Aug 08 17:14:34 CST 2016 password: myLittlePony Logon a=logon info: username: Hulk date: Mon Aug 08 17:14:34 CST 2016 password: null *///~