public class Test{
   public static void main(String args[]){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x);
   }
}
// 15Copy to clipboardErrorCopied

public class Test {
    public static void main (String []args)
    {
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
        System.out.println("0度的余弦值：" + Math.cos(0));
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
        System.out.println("1的反正切值：" + Math.atan(1));
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
        System.out.println(Math.PI);
    }
}
/**
90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值：0.7853981633974483
π/2的角度值：90.0
3.141592653589793
**/Copy to clipboardErrorCopied

• 参数的小数点后第一位小于 5，运算结果为参数整数部分。
• 参数的小数点后第一位大于 5，运算结果为参数整数部分绝对值 +1，符号（即正负）不变。
• 参数的小数点后第一位等于 5，正数运算结果为整数部分 +1，负数运算结果为整数部分。

public class Main {
  public static void main(String[] args) {
    double[] nums = { 1.4, 1.5, 1.6, -1.4, -1.5, -1.6 };
    for (double num : nums) {
      test(num);
    }
  }
  private static void test(double num) {
    System.out.println("Math.floor(" + num + ")=" + Math.floor(num));
    System.out.println("Math.round(" + num + ")=" + Math.round(num));
    System.out.println("Math.ceil(" + num + ")=" + Math.ceil(num));
  }
}
/**
Math.floor(1.4)=1.0
Math.round(1.4)=1
Math.ceil(1.4)=2.0
Math.floor(1.5)=1.0
Math.round(1.5)=2
Math.ceil(1.5)=2.0
Math.floor(1.6)=1.0
Math.round(1.6)=2
Math.ceil(1.6)=2.0
Math.floor(-1.4)=-2.0
Math.round(-1.4)=-1
Math.ceil(-1.4)=-1.0
Math.floor(-1.5)=-2.0
Math.round(-1.5)=-1
Math.ceil(-1.5)=-1.0
Math.floor(-1.6)=-2.0
Math.round(-1.6)=-2
Math.ceil(-1.6)=-1.0
**/

Integer i = new Integer(100);
Integer j = new Integer(100);
System.out.print(i == j); //falseCopy to clipboardErrorCopied

/**
 * 比较非new生成的Integer变量与new生成的Integer变量
 */
public class Test {
    public static void main(String[] args) {
        Integer i= new Integer(200);
        Integer j = 200;
        System.out.print(i == j);
        //输出：false
    }
}Copy to clipboardErrorCopied

/**
 * 比较两个非new生成的Integer变量
 */
public class Test {
    public static void main(String[] args) {
        Integer i1 = 127;
        Integer ji = 127;
        System.out.println(i1 == ji);//输出：true
        Integer i2 = 128;
        Integer j2 = 128;
        System.out.println(i2 == j2);//输出：false
    }
}Copy to clipboardErrorCopied

/**
 * 比较Integer变量与int变量
 */
public class Test {
    public static void main(String[] args) {
        Integer i1 = 200;
        Integer i2 = new Integer(200);
        int j = 200;
        System.out.println(i1 == j);//输出：true
        System.out.println(i2 == j);//输出：true
    }
}Copy to clipboardErrorCopied

Integer a = 1;
Integer a = Integer.valueOf(1);
/**
 * 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) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}Copy to clipboardErrorCopied

IntegerCache.cache[i + (-IntegerCache.low)]Copy to clipboardErrorCopied

Integer a = 1;
Integer b = 1;Copy to clipboardErrorCopied

// 使用简单类型比较
float a = 0.7f - 0.6f;
float b = 0.8f - 0.7f;
if (a == b) {
    System.out.println("true");
} else {
    System.out.println("false"); // false
}
// 使用封装类型比较
Float m = Float.valueOf(a);
Float n = Float.valueOf(b);
if (m.equals(n)) {
    System.out.println("true");
} else {
    System.out.println("false"); // false
}
// 使用 BigDecimal 比较
BigDecimal x = new BigDecimal(0.8f);
BigDecimal y = new BigDecimal("0.8");
if (x.equals(y)) {
    System.out.println("true");
} else {
    System.out.println("false"); // false
}Copy to clipboardErrorCopied

double diff = 1e-6;
if (Math.abs(a - b) < diff) {
    System.out.println("true"); // true
} else {
    System.out.println("false");
}
BigDecimal a1 = new BigDecimal("0.8");
BigDecimal b1 = new BigDecimal("0.7");
BigDecimal c1 = new BigDecimal("0.6");
if (a1.subtract(b1).equals(b1.subtract(c1))) {
    System.out.println("true"); // true
} else {
    System.out.println("false");
}Copy to clipboardErrorCopied

• 给数组赋值：通过 fill 方法。
• 对数组排序：通过 sort 方法,按升序。
• 比较数组：通过 equals 方法比较数组中元素值是否相等。
• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

import java.util.Arrays;
public class TestArrays {
    public static void output(int[] array) {
        if (array != null) {
            for (int i = 0; i < array.length; i++) {
                System.out.print(array[i] + " ");
            }
        }
        System.out.println();
    }
    public static void main(String[] args) {
        int[] array = new int[5];
        // 填充数组
        Arrays.fill(array, 5);
        System.out.println("填充数组：Arrays.fill(array, 5)：");
        TestArrays.output(array);
        // 将数组的第2和第3个元素赋值为8
        Arrays.fill(array, 2, 4, 8);
        System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
        TestArrays.output(array);
        int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };
        // 对数组的第2个到第6个进行排序进行排序
        Arrays.sort(array1, 2, 7);
        System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");
        TestArrays.output(array1);
        // 对整个数组进行排序
        Arrays.sort(array1);
        System.out.println("对整个数组进行排序：Arrays.sort(array1)：");
        TestArrays.output(array1);
        // 比较数组元素是否相等
        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" + Arrays.equals(array, array1));
        int[] array2 = array1.clone();
        System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" + Arrays.equals(array1, array2));
        // 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
        Arrays.sort(array1);
        System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" + Arrays.binarySearch(array1, 3));
        // 如果不存在就返回负数
        System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" + Arrays.binarySearch(array1, 9));
    }
}Copy to clipboardErrorCopied

Array.copy(E[] e,newLength);Copy to clipboardErrorCopied

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] a= {10,20,30,40,50};
        a= Arrays.copyOf(a,a.length+1);
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]);
        }
    }
}Copy to clipboardErrorCopied

• 数量非常小的情况下（就像上面说到的，少于 47 的），插入排序等可能会比快速排序更快所以数组少于 47 的会进入插入排序。
• 快排数据越无序越快（加入随机化后基本不会退化），平均常数最小，不需要额外空间，不稳定排序。
• 归排速度稳定，常数比快排略大，需要额外空间，稳定排序。

import java.util.Arrays;
public class sort1 {
    public static void main(String args[]) {
        int[] a= {9,8,7,6,4,5,3,1,2};
        Arrays.sort(a);
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+"");
        }
    }
}Copy to clipboardErrorCopied

import java.util.Arrays;
public class sort2 {
    public static void main(String args[]) {
        int[] a= {9,2,5,1,6,1,4,3,};
        Arrays.sort(a,0,3);
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+"");
        }
    }
}Copy to clipboardErrorCopied

import java.util.Arrays;
import java.util.Comparator;
public class sort3 {
    public static void main(String args[]) {
        Integer[] a= {9,5,6,1,3,2,4,7,8,0};
        Comparator cmp=new MyComparator();
        Arrays.sort(a);
        for(int i=0;i<a.length;i++) {
            System.out.print(a[i]+"");
        }
    }
}
class MyComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        // TODO Auto-generated method stub
        if(o1<o2) {
            return 1;
        }
        else if(o1>o2) {
            return -1;
        }else {
            return 0;
        }
    }
}Copy to clipboardErrorCopied

public class Car{
    private double speed;//车辆的速度属性
    public Car(double speed) {
        this.speed = speed;
    }
    public double getSpeed() {
        return speed;
    }
    public void setSpeed(double speed) {
        this.speed = speed;
    }
}Copy to clipboardErrorCopied

public class Car implements Comparable<Car>{
    private double speed;
    public Car(double speed) {
        this.speed = speed;
    }
    public double getSpeed() {
        return speed;
    }
    public void setSpeed(double speed) {
        this.speed = speed;
    }
    @Override
    public int compareTo(Car newCar) {
        return Double.compare(this.getSpeed(),newCar.getSpeed());
    }
}Copy to clipboardErrorCopied

dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法Copy to clipboardErrorCopied

arrayRefVar = new dataType[arraySize];Copy to clipboardErrorCopied

dataType[] arrayRefVar = new dataType[arraySize];
dataType[] arrayRefVar = {value0, value1, ..., valuek};Copy to clipboardErrorCopied

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}
// 数组作为函数的返回值
public static int[] reverse(int[] list) {
  int[] result = new int[list.length];
  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}Copy to clipboardErrorCopied

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}Copy to clipboardErrorCopied

for(type element: array)
{
    System.out.println(element);
}
public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};
      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}Copy to clipboardErrorCopied

String str[][] = new String[3][4];Copy to clipboardErrorCopied

type[][] typeName = new type[typeLength1][typeLength2];Copy to clipboardErrorCopied

int a[][] = new int[2][3];Copy to clipboardErrorCopied

String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");Copy to clipboardErrorCopied