java基础学习笔记（复习） ---- 数组

------- android培训、java培训、期待与您交流！ ----------

 

数组

数 组：用于存储同一类型数据的一个容器。

好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。

如何在java中表现一个数组呢？两种表现形式。

1）、元素类型[] 变量名 = new 元素类型[元素的个数]；

2）、元素类型[] 变量名 = {元素1，元素2...}；

元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；

数组的常见操作 - 获取最值

public class Test {

public static void main (String[] args) {

int[] temp = {4,2,7,19,20,40,1,0};

int max = getMax(temp);

System.out.println(max);

}

public static int getMax(int[] arr){

int max = 0; //定义变量最大值

for (int i = 0; i < arr.length; i++) {

if(arr[i] > max){

max = arr[i];

}

}

return max;

}

}

数组的常见操作 - 排序

选择排序 - 从大到小排序

（public static void sort(byte[] a)）arrays自带的排序函数

public class Test {

public static void main (String[] args) {

int[] temp = {4,2,7,19,20,40,1,0};

for (int i : temp) {

System.out.print(i + ",");

}

getSort(temp);

System.out.println();

for (int i : temp) {

System.out.print(i + ",");

}

}

public static void getSort(int[] arr){

for (int i = 0; i < arr.length-1; i++) {

for (int j = i+1; j < arr.length; j++) {

if(arr[i] < arr[j]){

int temp = 0;

temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

}

原理就是，从第一个角标开始，依次往后比较，所以要用到内外圈循环，符合条件则交换数组的位置，内外圈循环，可以解决很多类似的问题，比如 九九乘法表，形状排列等

for(int x = 1;x <= 9;x++){

for(int y = 1;y <= x;y++){

System.out.print(x + "*" + y +"=" + x*y + " ");

}

System.out.println();

}

九九乘法表

冒泡排序

public class Test {

public static void main (String[] args) {

int[] arr = {4,2,7,19,20,40,1,0};

print(arr);

getSort(arr);

System.out.println();

print(arr);

}

public static void getSort(int[] arr){

//冒泡排序，相邻的两个比较，第一轮之后，最值（大）会在最后

for(int i = 0;i<arr.length-1;i++){

for(int j=0;j<arr.length-1-i;j++){//最大的会往最后跑，所以范围递减

int temp = 0;

if(arr[j] > arr[j+1]){ //这里决定了 从小到大或是从大到小的顺序

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

public static void print(int[] arr){

for (int i : arr) {

System.out.print(i + ",");

}

}

}

在for循环中，提取代码。

if(arr[j] > arr[j+1]){ 

swap(arr, j, j+1); //这里来确定参数，想想变换位置的时候是三足鼎立，所以这里J 和J+1 位置也可以变

}

public static void swap(int[] arr,int a,int b){

int temp = 0;

temp = arr[a];

arr[a]= arr[b];

arr[b] = temp;

}

刚提出的时候，一筹莫展，不知道需要哪些参数，原来这里j，和j+1，包装成一个变量。就解决了在for循环中分离功能代码。

优化数组排序 - 性能问题

选择排序法，性能优化，在这之前是符合条件就要在数组中换位一次，现在原理是：用变量记录下最（小）值和最值角标，第一轮循环完成之后，直接把第一个元素和记录的最小元素调换位置。

public class Test {

public static void main (String[] args) {

int[] arr = {4,2,7,19,20,40,1,0};

print(arr);

getSort(arr);

System.out.println();

print(arr);

}

public static void getSort(int[] arr){

for(int i=0;i<arr.length-1;i++){

int temp = arr[i]; //记录最值

int index = i;//记录最值的角标

for (int j = i+1; j < arr.length; j++) {

if(temp > arr[j]){

temp = arr[j];

index = j;

}

}

if(arr[i] != temp){  //如果两个值相等，则就不需要换位置（又减少一次数组换位操作）

swap(arr, i, index); //这里的参数对比函数中的代码，发现这里其实是角标

}

}

}

public static void print(int[] arr){

for (int i : arr) {

System.out.print(i + ",");

}

}

public static void swap(int[] arr,int a,int b){

int temp = 0;

temp = arr[a];

arr[a]= arr[b];

arr[b] = temp;

}

}

 

 

数组常见功能 -  查找

普通查找 - 遍历

public class Test {

public static void main (String[] args) {

int[] arr = {4,2,7,19,20,40,1,0};

System.out.println(getIndex(arr,2));

}

/*普通遍历查找

 * */

public static int getIndex(int[] arr,int key){

for(int i=0;i<arr.length;i++){

if(key == arr[i]){

return i; //符合条件则直接退出当前循环并返回值

}

}

return -1; //如果没有找到，则返回 -1 值

}

}

典型的马虎大侠，为什么结果会执行else中的语句，正确结果应该打印1111，和返回 0，

但是此程序却，打印111，返回-2. 

public class Test {

public static void main (String[] args) {

int[] arr = {4,2,7,19,20,40,1,0};

System.out.println(getIndex(arr,4));

}

/*普通遍历查找

 * */

public static int getIndex(int[] arr,int key){

int temp = 0;

for(int i=0;i<arr.length;i++){ //一定要记得，这里是在for循环中，没break则还会继续

if(arr[i] == key){

temp = i;

System.out.println("1111111111");

            //break; //加上这句才会正确

}else{

temp = -2;

}

}

return temp;

}

}

折半查找法（二分查找法） - 前提是必须是有序的数组

(public static int binarySearch(byte[] a,byte key)) arrays自带的二分搜索

原理：确定中间的数，key 如果大于中间的数，则直接从右边再砍掉一半，确定中间数。这样查找效率上比较高效

 

public static void main (String[] args) {

int[] arr = {4,2,7,19,20,40,1,0};

print(arr); //排序前

System.out.println();

getSort(arr);//排序

print(arr);//排序后

System.out.println("\r\n" + getIndex(arr, 44));

System.out.println("\r\n" + getIndex2(arr, 4));

}

/*折半查找法，只适用于 有序的,方法一

 * */

public static int getIndex(int[] arr,int key){

int min = 0; //头角标

int max = arr.length-1; //尾角标

int mid = (min + max)/2; //确定mid中间角标

while(arr[mid] != key){

if(key > arr[mid]){//如果key大于中间角标数，则改变头脚本位置，尾脚本不变

min = mid + 1;

}else if(key < arr[mid]){

max = mid - 1;

}

if(max < min){

return -1;

}

mid = (min + max)/2; //继续折半动作

}

return mid;

}

/*折半查找方法二

 * */

public static int getIndex2(int[] arr,int key){

int min = 0; //头角标

int max = arr.length -1 ; //尾角标

int mid;

while(max > min){ //还有可能折半

mid = (min + max)>>1; //右移1位，表示除以2的1次方

if(key > arr[mid])

min = mid +1;

else if(key < arr[mid])

max = mid -1;

else

return mid; //当max = min 的时候，表示找到该数，（注意：找到就返回了，要注意循环中的条件逻辑判断）

//

}

return -1; //当最后一次，如果没有找到则会跳出循环（

//直接返回min则表示未找到key，但是该key应该插入到该角标位置，因为二分查找是有序数组）

//自带的 binarySearch(int[] arr,key) 返回的是 -min-1，告诉咱，该key未找到，并且在-min的绝对值位置插入

}

/*普通排序冒泡,相邻的两个数进行对比

 * */

public static void getSort(int[] arr){

for (int i = 0; i < arr.length-1; i++) {

for (int j = 0; j < arr.length-1-i; j++) {

if(arr[j] > arr[j+1]){

int temp = 0;

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

}

}

}

}

public static void print(int[] arr){

for(int i:arr){

System.out.print(i + ",");

}

}

}

 

进制转换

获取一个整数的16进制表现形式

一个整数占4个8（8个二进制位）位，1byte = 1字节 = 8个二进制位

 

public class Test {

public static void main (String[] args) {

int num = 60;

/*int n1 = num & 15; //先去最低四位

System.out.println(n1);

num = num >>> 4; //再右移4位，取得倒数第2个四位，

  //为什么是右移四位？因为16进制，到十进制，是逢10进一，4个二进制位，是12，刚好符合

int n2 = num & 15;

System.out.println(n2);*/

while(num != 0){

int temp = num & 15;

System.out.println(temp);

num = num >>> 4;

}

}

程序改进 - 16进制大于9之后的数字为 A，B ....

String[] str = {"0","1","2","3","4","5","6","7","8","9",

"A","B","C","D","E","F"};

while(num != 0){

int temp = num & 15;

if(temp > 9){

System.out.println(str[temp]);

}else{

System.out.println(temp);

}

num = num >>> 4;

}

 

还有一种方法，大于9，从10开始，(char)(temp - 10 + ‘a’) ; 阿斯特妈表值。

其实这个原理我还是没有听明白，

什么时候使用数组呢？

   如果数据出现了对应关系，而且对应关系的一方是有序数字编号，并作为角标使用，这时就必须要想到数组了

查表法：

    根据运算的节诶过作为角标直接去查数组中对应的元素即可

 

正确的查表法，结果还是倒着的，但是已经做到这里了，反转操作就已经很容易了

public class Test {

public static void main (String[] args) {

int num =-10;

if(num == 0){

System.out.println(0); //处理0的意外

return;  //这里又展示了优化内存的细节哦

}

String[] str = {"0","1","2","3","4","5","6","7","8","9",

"A","B","C","D","E","F"};

String[] str2 = new String[8]; //存储转换得到的数值

int pos = 0; //指针

while(num != 0){

int temp = num & 15;

str2[pos++] = str[temp]; 

num = num >>> 4;

}

for(int i =0;i < pos;i++){

System.out.print(str2[i]);

}

}

}

Int转二进制 - 原理一样

public class Test {

public static void main (String[] args) {

int num =60;

if(num == 0){

System.out.println(0); //处理0的意外

return;  //这里又展示了优化内存的细节哦

}

while(num != 0){

int temp = num & 1; //为什么是int转16进制，是右移4位(4位是15，逢16进1)

//所以 int转2进制是，右移1位，逢2进1，1位是数字1，2位是3.所以是&上1，右移1位

System.out.println(temp);

num = num >>> 1;

}

}

Int转8进制

public class Test {

public static void main (String[] args) {

/*int转八进制表现形式*/

int num = 0; //指定要转换的数字

if(num == 0){

System.out.println(0);

return;

} //处理0意外

while(num != 0){

int temp = num & 7;//取最低3位

System.out.println(temp);

num = num >>>3;//砍掉已经取走的三位

}

}

}

功能整合 - 合体进制转换功能

public class Test {

public static void main (String[] args) {

int key = 60;

System.out.println("16进制：");

char[] temp = to16(key);

print(temp);

System.out.println("\r\n" + Integer.toHexString(key)); //自带16进制转换

System.out.println("2进制：");

temp = to2(key);

print(temp);

System.out.println("\r\n" + Integer.toBinaryString(key));

System.out.println();

System.out.println("8进制：");

temp = to8(key);

print(temp);

System.out.println("\r\n" + Integer.toOctalString(key));

}

public static void print(char[] temp){

for(int i=temp.length-1;i >= 0; i--){

System.out.print(temp[i]);

}

}

//转16进制

public static char[] to16(int key){

char[] temp = transform(key, 15, 4);

return temp;

}

//转八进制

public static char[] to8(int key){

char[] temp = transform(key, 7, 3);

return temp;

}

//转二进制

public static char[] to2(int key){

char[] temp = transform(key, 1, 1);

return temp;

}

//转换功能，明确需要转换的数值，& 几？右移几？

public static char[] transform(int key,int a,int b){

char[] str = {'0','1','2','3','4','5','6','7','8','9',

'A','B','C','D','E','F'}; //定义表

if(key == 0){

System.out.println(0);

}

char[] result = new char[32]; //定义存储新的进制变量

int pos = 0; //指针，操作存取位置

while(key != 0){

int temp = key & a;

result[pos++] = str[temp];

key = key >>> b;

}

return result;

}

}

查表法练习

public class Test {

public static void main (String[] args) {

/*输入int星期数，返回中文星期*/

System.out.println(getWeek(1));

}

public static String getWeek(int key){

String[] weeks = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"};

if(key > 0 & key<8){

return weeks[key + 1];

}

return "请输入正确的星期";

}

}

二维数组[][]

内存图解

 

创建指定大小的二维数组

数组是引用型，在二维数组中默认初始化是 null，int是数据型，默认初始化是0.

要分清楚，如果不在数组中，直接定义int x; ,这样编译会出错，错误为未初始化。

public class Test {

public static void main (String[] args) {

int[][] arr = new int[3][2];

//创建一个二维数组，该数组中有3个一维数组，每个一维数组中有2个元素

arr[0][1] = 89; //给第一个一维数组中的第2个元素赋值

System.out.println(arr); //[[I@55f33675 @左边是实体的类型，右边是实体的哈希值

for (int i = 0; i < arr.length; i++) {

for (int j = 0; j < arr[i].length; j++) {

System.out.print(arr[i][j] + ",");

}

}

}

}

还可以像一维数组那样进行直接初始化

int[][] arr = {{1,2},{5,6},{44,33}};