java基础--数组Arrays、递归、移位运算、位运算符

一、Arrays类，数组工具类

三种声明数组的方法：
      int[] ary; ary = new int[]{1,2,3,4};

      int[] ary = {1,2,3,4};

      int[] ary = new int[4];
数组还有另外一种写法：int ary[];不过不赞成这样写。

两种访问方式：

      For each循环

      for 循环

一些常用的方法：
      Arrays.sort(数组引用变量) 按升序排序,效率非常高，比我们写的冒泡排序和插入排序效率高很多倍。而插入排序又比冒泡排序的效率高一些。
     Arrays.copyOf(数组引用变量，length)复制数组，以截取或则填充的形式使新的数组的长度为length.常用来增加数组大小。

     System.arraycopy(Object src,int srcPos,Object dest, int destPos,int length),也可以实现数组的复制。
     Arrays.binarySearch(数组引用变量，目标) 二分查找，必须在排序的数组中，在未排序的数组上查找的结果不确定。还可以指定在数组的什么范围搜索。
排序：sort 一般指由小到大的次序
有序：order 只是有先后次序，并没有规律，只是站成一排。
Arrys.toString(ary) 方便输出数组内容，不过不够灵活。
Arrays.copyOf() 底层就是 System.arraycopy() ，实现复制数组。System.copy() 灵活，可以复制部分数组元素，可以在已经存在的数组之间进行复制。      
插入式排序和冒泡排序:
import java.util.Arrays;
import java.util.Random;
public class Demo01 {
    public static void main(String[] args){
        int [] ary = new int[10000];
        Random random = new Random();
        for(int i = 0;i<ary.length;i++){
            ary[i] = random.nextInt(100);
        }
        int [] ary1 =Arrays.copyOf(ary,ary.length);

        long t1=System.currentTimeMillis();
       
        sort(ary);
        long t2=System.currentTimeMillis();       
        System.out.println(Arrays.toString(ary)+"用时"+(t2-t1));       
        long t3=System.currentTimeMillis();
        sort1(ary1);
        long t4=System.currentTimeMillis();
        System.out.println(Arrays.toString(ary1)+"用时"+(t4-t3));
    }
    //冒泡排序,从小到大
    public static void sort(int[] ary){
        for(int i = 0;i < ary.length-1;i++){
            for(int j = 0;j < ary.length-i-1;j++){
                if(ary[j] > ary[j+1]){
                    int t = ary[j];ary[j] = ary[j+1];ary[j+1] = t;
                }
            }
        }
    }
    //插入排序，从大到小
    public static void sort1(int[] ary){
        for(int i = 1;i < ary.length;i++){
            for(int j = 0;j < i;j++){
                if(ary[i] > ary[j]){
                    int t = ary[j];ary[j] = ary[i];ary[i] = t;
                }
            }
        }
    }
}
冒泡排序：比较相邻的元素，大数向后交换，交换次。总体比较完一轮，这一次就会将剩下的数中最大放到最后。n个数字就需要比较(n-1)+(n-2)+...+1
二、递归：
方法在执行期间调用自己。注意算法不要发散。深度不能太深。
public class Demo03 {
    public static void main(String[] args){
        int n = 5;
        int y = f(n);
        System.out.println(y);
        System.out.println(fib(5));
        System.out.println(fib(6));
        System.out.println(fib(7));
    }
    public static int f(int n){
        if(n == 1)
            return 1;
        return n+f(n-1);
    }
    //f(n)=f(n-2)+f(n-1),f(1)=f(2)=1，非常不适合用递归
    public static int fib(int n){
        if(n ==1 ||n == 2)
            return 1;
        return fib(n-2)+fib(n-1);
    }
}
三、移位运算：
针对整数做二进制移动，这种运算时很快的，比起乘除运算快很多。
<< 左移            向左移动一位，右边补0；相当于乘以2，当然这是在不超过范围的时候才成立。
>> 算数右移      向右移动一位，若高位是1补1，若高位是0补0.相当于除以2, 数学右移
>>>逻辑右移     向右移动一位，左边加0；
public class Demo04 {
    public static void main(String[] args){
        int n = 0xe0000007;
        System.out.println(Integer.toBinaryString(n));      //   11100000000000000000000000000111
        System.out.println(Integer.toBinaryString(n<<1));//   11000000000000000000000000001110
        System.out.println(Integer.toBinaryString(n>>1));//    11110000000000000000000000000011
        System.out.println(Integer.toBinaryString(n>>>1));//   1110000000000000000000000000011
        System.out.println(Integer.toBinaryString(n<<2));//    10000000000000000000000000011100
        System.out.println(Integer.toBinaryString(n>>2));//    11111000000000000000000000000001
        System.out.println(Integer.toBinaryString(n>>>2));//   111000000000000000000000000001
        n=27;  
        System.out.println(Integer.toBinaryString(n));  //11011   
        System.out.println(n>>1);    //13   
        System.out.println(n>>>1);  //13
        System.out.println(n<<1);  //54
        n=-26;//  11010
        System.out.println(n>>1);  //-13
        System.out.println(n>>>1); //?2147483635
        System.out.println(n<<1); //-52
    }
}
011101011 >> 2  000111010 相当于除以4
011101011 & 000000011 相当于对4取余
~n == -n-1;
从一个byte数组中offset开始连续取出四个byte数据，拼接成一个int数据。
public class Demo03 {
    public static void main(String[] args){
        byte[] data ={0x05,0x0a,0x0b,(byte)0xff,(byte)0xff,(byte)0xff,
                (byte)0xfe,0x09,0x4e,0x2d};   
    /*当int范围不超过byte范围时会自动赋值，超过的时候我们需要强制转换。
    强制转换是取后面的位数。   System.out.println(Integer.toBinaryString(0xff));输出结果是11111111，这个结果是255.从这个结果也可以看过强制转换
    取的是位数的后面。
    */
        int n = parseInt(data,3);
        System.out.println(n);
    }
    public static int parseInt(byte[] data,int offset){
        int b1,b2,b3,b4;
        int n;
        b1 = data[offset] & 0xff;//byte ->int 有符号位的扩展
        b2 = data[offset + 1] & 0xff;
        b3 = data[offset + 2] & 0xff;
        b4 = data[offset + 3] & 0xff;
        n = (b1<<24) +(b2<<16) + (b3<<8) +(b4);
        return n;
    }
}
    data = {05,0a,0b,ff,ff,ff,fe,09,4e,2d}
四、位运算符：
& 按位与     |按位或      ^按位异或      ~按位非，对整数类型（包括char）按照二进制位逐位进行逻辑运算。
掩码运算：截取一个int数据的部分数据。
int mask = 0xff;int color = ox4f9a57; System.out.println(mask & color);\\可以将该颜色中的B分量取出来。
System.out.println((color>>>8)&mask);G分量
System.out.println((color>>>16)&mask);R分量