Atecher's blog

import java.util.Arrays;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        //注意summer是小写
        List<String> params = Arrays.asList("Spring", "summer");
        for (String name : params) {
            //查找表面值与name相同的枚举项
            Season s = Season.valueOf(name);
            if (s != null) {
                // 有该枚举项时的处理
                System.out.println(s);
            } else {
                // 没有该枚举项时的逻辑处理
                System.out.println("无相关枚举项");
            }
        }
    }
}

enum Season {
    Spring, Summer, Autumn, Winter;
}

public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
        T result = enumType.enumConstantDirectory().get(name);//通过反射,从常量列表中查找.
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(//最后报无效参数异常
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

try {
    Season s = Season.valueOf(name);
    // 有该枚举项时的处理
    System.out.println(s);
} catch (Exception e) {
    System.out.println("无相关枚举项");
}

enum Season {
    Spring, Summer, Autumn, Winter;
    public boolean contains(String _name){
        Season[] season = values();
        for(Season s:season){
            if(s.name().equals(_name)){
                return true;
            }
        }
        return false;

    }
}

import java.util.Arrays;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        // 注意summer是小写
        List<String> params = Arrays.asList("Spring", "summer");
        for (String name : params) {
            // 查找表面值与name相同的枚举项
//            Season s = Season.valueOf(name);
//            if (s != null) {
//                // 有该枚举项时的处理
//                System.out.println(s);
//            } else {
//                // 没有该枚举项时的逻辑处理
//                System.out.println("无相关枚举项");
//            }
            if (Season.contains(name)) {
                Season s = Season.valueOf(name);
                // 有该枚举项时的处理
                System.out.println(s);
            } else {
                System.out.println("无相关枚举项");
            }
        }
    }
}

enum Season {
    Spring, Summer, Autumn, Winter;

    // 是否包含指定名称的枚举项
    public static boolean contains(String name) {
        Season[] season = values(); // 所有的枚举值

        // 遍历查找
        for (Season s : season) {
            if (s.name().equals(name)) {
                return true;
            }
        }
        return false;
    }
}

import org.apache.commons.lang3.builder.ToStringBuilder;
public class Client{
    public static void main(String[] args){
        //气球的数量
        int ballonNum = 7;
        //第一个箱子
        Ballon[] box1 = new Ballon[ballonNum];
        //初始化第一个箱子
        for(int i = 0; i < ballonNum; i++){
            box1[i] = new Ballon(Color.values()[i],i);
        }

        //第二个箱子的小球是拷贝的第一个箱子里的
        Ballon[] box2 = Arrays.copyOf(box1,box1.length);
        //修改最后一个气球的颜色
        box2[6].setColor(Color.Blue);
        //打印出第一个箱子中的气球颜色
        for(Ballon b:box1){
            System.out.println(b);
        }
    }
}

//气球的颜色
enum Color{
    Red,Orange,Yellow,Green,Indigo,Blue,Violet;
}

//气球
class Ballon{
    private int id; //编号
    private Color color; //颜色

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public Color getColor() {
        return color;
    }
    public void setColor(Color color) {
        this.color = color;
    }
    public Ballon(Color _color,int _id){
        color = _color;
        id = _id;
    }

    /*id、color的getter/setter方法省略*/
    //apache-common包下的ToStringBuilder重写toString方法
    public String toString(){
        return new ToStringBuilder(this).append("编号",id).append("颜色",color).toString();
    }
}

public class Client {
    public static void main(String[] args) {
         //定义父亲
         Person f = new Person("父亲");
         //定义大儿子
         Person s1 = new Person("大儿子",f);
         //小儿子的信息是通过大儿子拷贝过来的
         Person s2 = s1.clone();
         s2.setName("小儿子");
         System.out.println(s1.getName() +" 的父亲是 " + s1.getFather().getName());
         System.out.println(s2.getName() +" 的父亲是 " + s2.getFather().getName());
    }
}

class Person implements Cloneable{
    //姓名
    private String name;
    //父亲
    private Person father;

    public Person(String _name){
         name = _name;
    }
    public Person(String _name,Person _parent){
         name = _name;
         father = _parent;
    }
    /*name和parent的getter/setter方法省略*/

    //拷贝的实现
    @Override
    public Person clone(){
         Person p = null;
         try {
           p = (Person) super.clone();
         } catch (CloneNotSupportedException e) {
           e.printStackTrace();
         }
         return p;
   }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Person getFather() {
        return father;
    }
    public void setFather(Person father) {
        this.father = father;
    }
}

public Person clone(){
     Person p = null;
     try {
        p = (Person) super.clone();
        p.setFather(new Person(p.getFather().getName()));
     } catch (CloneNotSupportedException e) {
        e.printStackTrace();
     }
     return p;
}

public class CloneUtils {
     // 拷贝一个对象
     @SuppressWarnings("unchecked")
     public static <T extends Serializable> T clone(T obj) {
          // 拷贝产生的对象
          T clonedObj = null;
          try {
            // 读取对象字节数据
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);
            oos.close();
            // 分配内存空间，写入原始对象，生成新对象
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            //返回新对象，并做类型转换
            clonedObj = (T)ois.readObject();
            ois.close();
         } catch (Exception e) {
            e.printStackTrace();
         }
         return clonedObj;
     }
}

class Person implements Serializable{
     private static final long serialVersionUID = 1611293231L;
     /*删除掉clone方法，其他代码保持不变*/
}

import java.util.Arrays;
import java.util.List;
public class Client {
    public static void main(String[] args) {
        int[] data = {1,2,3,4,5};
        List list = Arrays.asList(data);
        System.out.println("列表中的元素数量是：" + list.size());
    }
}

/*
运行结果: 
列表中的元素数量是：1
*/

/**
 * Returns a fixed-size list backed by the specified array.  (Changes to
 * the returned list "write through" to the array.)  This method acts
 * as bridge between array-based and collection-based APIs, in
 * combination with {@link Collection#toArray}.  The returned list is
 * serializable and implements {@link RandomAccess}.
 *
 * <p>This method also provides a convenient way to create a fixed-size
 * list initialized to contain several elements:
 * <pre>
 *     List&lt;String&gt; stooges = Arrays.asList("Larry", "Moe", "Curly");
 * </pre>
 *
 * @param a the array by which the list will be backed
 * @return a list view of the specified array
 */
@SafeVarargs
public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

import java.util.Arrays;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        int[] data = {1,2,3,4,5};
        List list = Arrays.asList(data);
        System.out.println("元素类型：" + list.get(0).getClass());
        System.out.println("前后是否相等："+data.equals(list.get(0)));
    }
}
/*
运行输出:
元素类型：class [I
前后是否相等：true
*/

import java.util.Arrays;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        Integer[] data = {1,2,3,4,5};
        List list = Arrays.asList(data);
        System.out.println("列表中的元素数量是：" + list.size());
    }
}
/*
运行输出:
列表中的元素数量是：5
*

public class JavaIntegerCache {
	public static void main(String... strings) {
		Integer integer1 = 3;
		Integer integer2 = 3;
		if (integer1 == integer2)
			System.out.println("integer1 == integer2");
		else
			System.out.println("integer1 != integer2");

		Integer integer3 = 300;
		Integer integer4 = 300;
		if (integer3 == integer4)
			System.out.println("integer3 == integer4");
		else
			System.out.println("integer3 != integer4");
	}
}

/*执行结果
integer1 == integer2
integer3 != integer4
*/

/**
 * Returns an {@code Integer} instance representing the specified
 * {@code int} value.  If a new {@code Integer} instance is not
 * required, this method should generally be used in preference to
 * the constructor {@link #Integer(int)}, as this method is likely
 * to yield significantly better space and time performance by
 * caching frequently requested values.
 *
 * This method will always cache values in the range -128 to 127,
 * inclusive, and may cache other values outside of this range.
 *
 * @param  i an {@code int} value.
 * @return an {@code Integer} instance representing {@code i}.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

/**
 * Cache to support the object identity semantics of autoboxing for values between
 * -128 and 127 (inclusive) as required by JLS.
 *
 * The cache is initialized on first usage.  The size of the cache
 * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
 * During VM initialization, java.lang.Integer.IntegerCache.high property
 * may be set and saved in the private system properties in the
 * sun.misc.VM class.
 */

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

public class Client {
    public static final int MAX_LOOP = 50000;
    public static void main(String[] args) {
        doWithPlus();
        doWithConcat();
        doWithStringBuffer();
        
        String str ="abc";
        String str1 = str.concat("1");
        String str2 = "abc1";
        System.out.println(str1 == str2);
    }
    
    public static void doWithPlus(){
        String str = "a";
        long start = System.currentTimeMillis();
        for(int i=0;i<MAX_LOOP;i++){
            str += "c";
            //str = new StringBuilder(prefix).append("c").toString();
        }
        long finish = System.currentTimeMillis();
        System.out.println("doWithPlus:" + (finish - start) + "ms");
    }
    
    public static void doWithConcat(){
        String str = "a";
        long start = System.currentTimeMillis();
        for(int i=0;i<MAX_LOOP;i++){
            str = str.concat("c");
        }
        long finish = System.currentTimeMillis();
        System.out.println("doWithConcat:" + (finish - start) + "ms");
    }
    
    public static void doWithStringBuffer(){
        StringBuilder sb = new StringBuilder("a");
        long start = System.currentTimeMillis();
        for(int i=0;i<MAX_LOOP;i++){
            sb.append("c");
        }
        String str = sb.toString();
        long finish = System.currentTimeMillis();
        System.out.println("doWithStringBuffer:" + (finish - start) + "ms");
    }
}

/*
运行结果:
doWithPlus:1559ms
doWithConcat:748ms
doWithStringBuffer:2ms
false
*/

str = new StringBuilder(str).append("c").toString();

public String concat(String str) {
    int otherLen = str.length();
    //如果追加的字符串长度为0,着返回字符串本身
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    //追加的字符串转化成字符数组,添加到buf中
    str.getChars(buf, len);
    //复制字符数组,产生一个新的字符串
    return new String(buf, true);
}

public AbstractStringBuilder append(String str) {
    if (str == null) str = "null";//如果是null值,则把null作为字符串处理
    int len = str.length();
    ensureCapacityInternal(count + len);//加长,并作数组拷贝
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

public class Client {
    public static void main(String[] args) {
        Random r = new Random();
        for(int i=1;i<4;i++){
            System.out.println("第"+i+"次："+r.nextInt());
        }  
     }  
}

public class Client {
    public static void main(String[] args) {
        Random r = new Random(1000);
        for (int i = 1; i < 4; i++) {
            System.out.println("第" + i + "次：" + r.nextInt());
        }
    }
}

/*运行结果:
第1次：-1244746321
第2次：1060493871
第3次：-1826063944
*/

/**
 * Creates a new random number generator. This constructor sets
 * the seed of the random number generator to a value very likely
 * to be distinct from any other invocation of this constructor.
 */
public Random() {
    this(seedUniquifier() ^ System.nanoTime());
}

/**
 * Creates a new random number generator using a single {@code long} seed.
 * The seed is the initial value of the internal state of the pseudorandom
 * number generator which is maintained by method {@link #next}.
 *
 * <p>The invocation {@code new Random(seed)} is equivalent to:
 *  <pre> {@code
 * Random rnd = new Random();
 * rnd.setSeed(seed);}</pre>
 *
 * @param seed the initial seed
 * @see   #setSeed(long)
 */
public Random(long seed) {
    if (getClass() == Random.class)
        this.seed = new AtomicLong(initialScramble(seed));
    else {
        // subclass might have overriden setSeed
        this.seed = new AtomicLong();
        setSeed(seed);
    }
}

/**
 * Returns a {@code double} value with a positive sign, greater
 * than or equal to {@code 0.0} and less than {@code 1.0}.
 * Returned values are chosen pseudorandomly with (approximately)
 * uniform distribution from that range.
 *
 * <p>When this method is first called, it creates a single new
 * pseudorandom-number generator, exactly as if by the expression
 *
 * <blockquote>{@code new java.util.Random()}</blockquote>
 *
 * This new pseudorandom-number generator is used thereafter for
 * all calls to this method and is used nowhere else.
 *
 * <p>This method is properly synchronized to allow correct use by
 * more than one thread. However, if many threads need to generate
 * pseudorandom numbers at a great rate, it may reduce contention
 * for each thread to have its own pseudorandom-number generator.
 *
 * @return  a pseudorandom {@code double} greater than or equal
 * to {@code 0.0} and less than {@code 1.0}.
 * @see Random#nextDouble()
 */
public static double random() {
    return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
}

private static final class RandomNumberGeneratorHolder {
    static final Random randomNumberGenerator = new Random();
}