Java中值与引用

Java中基本类型

Java中数据类型分两种：
1.基本类型：long,int,byte,float,double。这些都是值类型。
2.对象类型：Long,Integer,Byte,Float,Double其它一切java提供的，或者你自己创建的类。这些是引用类型。

值类型在传递参数时只能复制：

int i = 5;

void add(int i);

例如这里的add函数中传入的i是前面的i的复制，add中对i进行修改不会影响到前面的i。

对于数组传值，能否改变数组里面的值或者把数组重新分配呢？看下面两段代码：

int[] test = new int[] {3,24,24,25};        (new TestList()).fixArray(test);        for (int n : test) {            System.out.print(n);        }        System.out.println();        (new TestList()).changeArray(test);        for (int n : test) {            System.out.print(n);        }        System.out.println();   public void fixArray(int[] t) {        t[0] = 5;    }    public void changeArray(int[] t) {        t = new int[] {2, 3};    }

输出的数组都是[5,24,24,25],这说明数组传递的是引用类型，但是changeArray这里无法修改原来的数组，说明这个引用是原引用的copy，有点想C++里面初始化链表的时候，要修改链表头部：createList(ListNode * &node);或者createList(ListNode ** node);这样才能修改到原指针，如果只是createList(ListNode * node);那么这里的指针就是原指针的复制,详见:

C++中引用，指针，指针的引用，指针的指针

所以引用类型在传递参数时时是传递引用的复制：

class A {    int i = 0;    public void set(int i) {        this.i = i;    }}A a1 = new A();A a2 = a1;a2.set(7);System.out.println(a1.i); //7

这里a2和a1都是同一个对象的引用（a2相当于指针的复制），修改a2的值a1,也很变。

前面说过Long和String也是引用类型，那么修改List<Long>中的值，修改完之后，List中的值是否变了呢？

        ArrayList<Long> l = new ArrayList<>();        l.add(5L);        Long tl = l.get(0);        tl = 6L;        tl = l.get(0);        System.out.println(tl); // 5L

可看到List中的值没有变，我们要修改List中的Long需要重新put, t1.put(0, 6L)。

        ArrayList<A> t = new ArrayList<>();        t.add(new A());        A a = t.get(0);        a.set(5);        a = t.get(0);        System.out.println(a.i); //5

普通引用对象，修改了a List中的值也变了，不需要重新put。

这是因为Long,String这些是immutable类型，也就是说每次修改都会创建一个新的对象（和 python中一样）。

Immutable不可变类型

那么什么是immutable objects?什么又是mutable Objects呢？
immutable Objects就是那些一旦被创建，它们的状态就不能被改变的Objects，每次对他们的改变都是产生了新的immutable的对象，而mutable Objects就是那些创建后，状态可以被改变的Objects.
举个例子：String和StringBuilder，String是immutable的，每次对于String对象的修改都将产生一个新的String对象，而原来的对象保持不变，而StringBuilder是mutable，因为每次对于它的对象的修改都作用于该对象本身，并没有产生新的对象。

但有的时候String的immutable特性也会引起安全问题，这就是密码应该存放在字符数组中而不是String中的原因！

immutable objects 比传统的mutable对象在多线程应用中更具有优势，它不仅能够保证对象的状态不被改变，而且还可以不使用锁机制就能被其他线程共享。

实际上JDK本身就自带了一些immutable类，比如String，Integer以及其他包装类。为什么说String是immutable的呢？比如：java.lang.String 的trim，uppercase,substring等方法，它们返回的都是新的String对象，而并不是直接修改原来的对象。

如何在Java中写出Immutable的类？

要写出这样的类，需要遵循以下几个原则：

1）immutable对象的状态在创建之后就不能发生改变，任何对它的改变都应该产生一个新的对象。

2）Immutable类的所有的属性都应该是final的。

3）对象必须被正确的创建，比如：对象引用在对象创建过程中不能泄露(leak)。

4）对象应该是final的，以此来限制子类继承父类，以避免子类改变了父类的immutable特性。

5）如果类中包含mutable类对象，那么返回给客户端的时候，返回该对象的一个拷贝，而不是该对象本身（该条可以归为第一条中的一个特例）

当然不完全遵守上面的原则也能够创建immutable的类，比如String的hashcode就不是final的，但它能保证每次调用它的值都是一致的，无论你多少次计算这个值，它都是一致的，因为这些值的是通过计算final的属性得来的！

另外，如果你的Java类中存在很多可选的和强制性的字段，你也可以使用建造者模式来创建一个immutable的类。

下面是一个例子：

?

public final class Contacts {     private final String name;    private final String mobile;     public Contacts(String name, String mobile) {        this.name = name;        this.mobile = mobile;    }       public String getName(){        return name;    }       public String getMobile(){        return mobile;    }}

我们为类添加了final修饰，从而避免因为继承和多态引起的immutable风险。

上面是最简单的一种实现immutable类的方式，可以看到它的所有属性都是final的。

有时候你要实现的immutable类中可能包含mutable的类，比如java.util.Date,尽管你将其设置成了final的，但是它的值还是可以被修改的，为了避免这个问题，我们建议返回给用户该对象的一个拷贝，这也是Java的最佳实践之一。下面是一个创建包含mutable类对象的immutable类的例子：

?

public final class ImmutableReminder{    private final Date remindingDate;       public ImmutableReminder (Date remindingDate) {        if(remindingDate.getTime() < System.currentTimeMillis()){            throw new IllegalArgumentException("Can not set reminder” +                        “ for past time: " + remindingDate);        }        this.remindingDate = new Date(remindingDate.getTime());    }       public Date getRemindingDate() {        return (Date) remindingDate.clone();    }}

上面的getRemindingDate()方法可以看到，返回给用户的是类中的remindingDate属性的一个拷贝，这样的话如果别人通过getRemindingDate()方法获得了一个Date对象，然后修改了这个Date对象的值，那么这个值的修改将不会导致ImmutableReminder类对象中remindingDate值的修改。

使用Immutable类的好处：
1）Immutable对象是线程安全的，可以不用被synchronize就在并发环境中共享

2）Immutable对象简化了程序开发，因为它无需使用额外的锁机制就可以在线程间共享

3）Immutable对象提高了程序的性能，因为它减少了synchroinzed的使用

4）Immutable对象是可以被重复使用的，你可以将它们缓存起来重复使用，就像字符串字面量和整型数字一样。你可以使用静态工厂方法来提供类似于valueOf（）这样的方法，它可以从缓存中返回一个已经存在的Immutable对象，而不是重新创建一个。

immutable也有一个缺点就是会制造大量垃圾，由于他们不能被重用而且对于它们的使用就是”用“然后”扔“，字符串就是一个典型的例子，它会创造很多的垃圾，给垃圾收集带来很大的麻烦。当然这只是个极端的例子，合理的使用immutable对象会创造很大的价值。