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分量