一、Arrays类,数组工具类
三种声明数组的方法:
int[] ary; ary = new int[]{1,2,3,4};
int[] ary; ary = new int[]{1,2,3,4};
int[] ary = {1,2,3,4};
int[] ary = new int[4];
数组还有另外一种写法:int ary[];不过不赞成这样写。
数组还有另外一种写法:int ary[];不过不赞成这样写。
两种访问方式:
For each循环
for 循环
一些常用的方法:
Arrays.sort(数组引用变量) 按升序排序,效率非常高,比我们写的冒泡排序和插入排序效率高很多倍。而插入排序又比冒泡排序的效率高一些。
Arrays.copyOf(数组引用变量,length)复制数组,以截取或则填充的形式使新的数组的长度为length.常用来增加数组大小。
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分量
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分量