[其他交流] ”数组“笔记提交专用帖

汤姆大叔 · 汤姆大叔

笔记内容：数组
      笔记来源：毕向东Java基础视频第4天
      正文：
一：数组的定义：同一种类型数据的集合。其实数组就是一个容器。
      格式1：元素类型[] 数组名 = new 元素类型[元素长度或数组个数]；
         实例：int[] arr = new int[5];
      格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，元素……};
         示例：int[] arr = new int[]{2,4,7,5};
               int[] arr = {6,3,8,9};
二：内存结构：栈内存，堆内存，方法区，本地方法区，寄存器。
      栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
      堆内存：1.数组和对象，通过new建立的实例都存放在堆内存中。
                     2.每一个实体都有内存地址值。
                     3.实体中的变量都有默认初始化值 (int:0 , double:0.0 , floot:0.0f  boolean:false)
                     4.实体不在被使用，会在不确定的时间内被垃圾回收器回收。

         垃圾回收机制：数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个                               不确定的时间被垃圾回收器释放掉。
三：静态初始化，常见问题.
         int[ ] arr = 和 int  arr[ ]    两种书写方式都正确。
         int[ ] arr = new int[ ]{3,7,4,8}  此时 [ ]中尽量不要写长度
         数组脚标越界异常(ArrayIndexOutOfBoundsException)：
         int [ ] arr = new int [ 3 ];
         System.out.println(arr[3]);    可以编译成功，但是运行失败。  因为运行的时候，才会在堆内存中开辟空间
         操作数组时，访问到了数组中不存在的角标。
         空指针异常(NullPointerException)：
         int[ ]  arr = null;
         System.out.println(arr[1]);
         arr引用没有指向实体，却在操作实体中的元素时。
四：遍历

class ArrayDemo3
{ public static void main(String[] args)
{
//数组的操作
//获取数组的元素，通常会用到遍历
int arr[] = {9,4,56,19,7,5};
printArray(arr);
}
// 定义一个功能：用于打印数组的元素。元素间用逗号隔开 1。没有结果因为打印了用void 2.有未知元素参与
//数组中有一个元素可以直接获取数组的个数或者长度。 .length
//int num = 0;
//使用方式；数组名称.length =
public static void printArray(int[] arr)
{
System.out.print("[");
for(int x=0;x<arr.length;x++)
{
//if(x<arr.length-1)
if(x!=arr.length-1)
System.out.print(arr[x]+",");
else
System.out.println(arr[x]+"]");
}
}
}

复制代码

需要注意的地方：

System.out.println(arr);
显示：[I@de6ced
[ = 数组
I = int
de6ced = 数组内存存放地址由哈希算法算出来的哈希值，十六进制数

复制代码

五：获取最值：

/*
给定一个数组 {3,5,1,7,9,6} 打印出数组中的最大值
*/
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = new int[]{3,5,1,7,9,6};
double[] arrd = new double[]{5.4,6.9,8.8,2.6,5.1};
int max = getMax(arr);
double maxd = getMax(arrd);
System.out.println("Max = "+max);
System.out.println("Max = "+maxd);
}
/*
给定一个数组 {3,5,1,7,9,6} 打印出数组中的最大值
步骤：
1，定义一个函数，遍历数组，先定义一个变量，赋值，可以为数组中的任何一个数值
2，其他数组值和改值进行比较，然后如果比该值大，那么就赋值给这个变量。
3，在主函数中调用这个函数，打印输出。
定义函数：
1.判断函数是否有返回值：有，返回int类型。
2.是否有未知参数：有，函数需要接受数组。定义参数类型为 int[]
*/
//第一种方法。
//第二种方法：临时变量可以初值化为0吗？答案是可以的，因为数组中的每一个元素都对应一个标号。
//所以用临时变量储存标号即可。
public static int getMax(int[] arr)
{
// int max = arr[0];
int max = 0;
for(int x=1;x<arr.length;x++)
{
// if(max<arr[x])
// {
// max = arr[x];
// }
if(arr[max]<arr[x])
{
max = x;
}
}
return arr[max];
}
//利用第二种方法，求出double类型的数组的最大值。
//此时我们可以定义一个同名但是有不同参数类型的 getMax进行重载操作
// 我们假设给定的数组为{5.4,6.9,8.8,2.6,5.1}
public static double getMax(double[] arr)
{
int max = 0;
for(int x=1;x<arr.length;x++)
{
if(arr[max]<arr[x])
{
arr[max] = arr[x];
}
}
return arr[max];
}
}

复制代码

六：选择排序和冒泡排序：

import java.util.*;
/*
选择排序 {8,5,1,9,4,7}
给定数组，按照从小大的顺序排列。
*/
class ArrayTest2
{
public static void main(String[] args)
{
int[] arr = new int[]{8,5,1,9,4,7};
//排序前
printArray(arr);
//选择排序
// selectSort(arr);
//冒泡排序
bubbleSort(arr);
//排序后
printArray(arr);
//java中已经定义好的一种排序方式，开发中，对数组排序，要使用该局代码
Arrays.sort(arr);
}
//冒泡排序
public static void bubbleSort(int[] arr)
{
for (int x=0;x<arr.length-1;x++ )
{
for (int y=0;y<arr.length-x-1 ;y++ )
{
if (arr[y]>arr[y+1])
{
/*
int temp = arr[y+1];
arr[y+1] = arr[y];
arr[y] = temp;
*/
swap(arr,y,y+1);
}
}
}
}
//选择排序
//内循环结束一次，最值出现在头角标位置上。
public static void selectSort(int[] arr)
{
for (int x = 0;x<arr.length-1 ;x++ )
{
for (int y=x;y<arr.length-1 ;y++ )
{
if (arr[x]>arr[y+1])
{
// int temp = arr[x];
// arr[x] = arr[y+1];
// arr[y+1] = temp;
swap(arr,x,y+1); //自己在操作中误写成 swap(int[] arr,int x,int y+1); 需要注意
}
}
}
}
//不论什么排序都需要对满足条件的元素进行位置的置换，所以可以将这部分代码单独的提取出来。单独封装成一个函数。
//该函数中应该有3个未知函数，因为在获取角标的前提是，先要确定数组。所以，需要定义三个参数， int[] arr,int a ,int b
//置换功能
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
//打印数组
public static void printArray(int[] arr)
{
System.out.print("数组为 "+"[ ");
for (int x=0;x<arr.length ;x++ )
{
if (x!=arr.length-1)
System.out.print(arr[x]+" ");
else
System.out.println(arr[x]+" ]");
}
}
}

复制代码

七：折半查找

/*
折半查找
数组 {3,8,9,16,20,35}
折半查找数组必须是有序的
*/
class ArrayTest4
{
public static void main(String[] args)
{
//查找 20在元素中的位置
int[] arr = new int[]{3,8,9,16,20,35};
// int index = getIndex(arr,35);
// int index = halfSearch(arr,35);
int index = halfSearch_2(arr,35);
System.out.println("index = "+index);
}
/*
步骤：
1，定义3个变量，记录每次比较实际的最大值，最小值和中间值的角标。max min mid
2，遍历数组，
3，使用mid的值，于需要查找的值比较，判断大小。
4，比较完大小之后，重新定义所查找的范围。使用循环语句，继续比较，知道查到改值。
5，如果改值不存在，那么返回 -1。
定义一个函数，方便该功能的复用性。
1，因为是返回数组中数值的角标，所以返回值类型为int
2，因为是查找某一数值，同时数组不确定，所以又两个参数， int[] arr,int x
*/
//折半查找
public static int halfSearch(int[] arr,int key)
{
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(key!=arr[mid]) //写代码过程中，误将arr[mid]写成 mid ！！！！！
{
if(key<arr[mid])
max = mid-1;
else if(key>arr[mid])
min = mid+1;
if(min>max)
return -1;
mid = (max+min)/2;
}
return mid;
}
//折半查找的第二种方法。
public static int halfSearch_2(int[] arr,int key)
{
int min,max,mid;
min = 0;
max = arr.length-1;
while (min<max) //第一次书写，min<max 正确写法是 min<=max 需要注意。
{
mid = (min+max)>>>1;
if (key>arr[mid])
min = mid + 1;
else if(key<arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
//数组查找，给定一个数组，判断在数组中的位置
public static int getIndex(int[] arr,int key)
{
for (int x=0;x<arr.length ;x++ ) //书写代码过程中，误将arr.length写成arr.length-1 ！！！！！
{
if (key==arr[x])
{
return x;
}
}
return -1;
}
}

复制代码

由于字数限制，分为两个来发帖了

汤姆大叔 · 汤姆大叔

八：查表法二进制终结版本：

class ArrayTest7
{
public static void main(String[] args)
{
toBin(0);
toOct(60);
toHex(-60);
}
//十进制转二进制
public static void toBin(int num)
{
trans(num,1,1);
}
//十进制转八进制
public static void toOct(int num)
{
trans(num,7,3);
}
//十进制转十六进制
public static void toHex(int num)
{
trans(num,15,4);
}
//代码功能的提取。
public static void trans(int num,int base,int offset)
{
//如果给的数值为0 的话，那么整个函数就停止运转
//所以要对0进行判断
if (num == 0)
{
System.out.println(0);
return;
}
char[] chs = {'0','1','2','3','4'
,'5','6','7','8','9'
,'A','B','C','D','E','F'};
char[] arr = new char[32];
int pos = arr.length;
while (num!=0)
{
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
for (int x = pos;x <arr.length ; x++)
{
System.out.print(arr[x]);
}
System.out.println();
}
}

复制代码

九：二维数组：数组中的数组。
格式：
格式1：int[ ][ ] arr = new int[3][4];

定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有4个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 56;

               格式2：int[][] arr = new int[3][];

                  二维数组中有3个一维数组
                  每个一维数组都是默认初始化值null
                  可以对这个三个一维数组分别进行初始化
                  arr[0] = new int[3];
                  arr[1] = new int[4];
                  arr[2] = new int[5];
               格式3：int[][] arr = {{3,8,2,6},{2,7,8,3},{9,0,1,6}};
      联系：一个公司有3个小组，求该公司一年中，所有小组，4个季度的业绩综合。

class ArrayTest8
{
public static void main(String[] args)
{
int[][] arr ={{3,2,5,7},{9,1,6,3},{6,6,4,3}};
int sum = getSum(arr);
System.out.println("该公司3个小组，4个季度的业绩综合为 = " +sum);
}
//定义一个功能。计算该公司 3个小组，4个季度的业绩综合。
public static int getSum(int[][] arr)
{
int sum = 0;
for (int x=0;x<arr.length ;x++ )
{
for (int y=0;y<arr[x].length ;y++ )
{
sum += arr[x][y]; //书写过程中，写成arr[y],错误提醒，数组类型不能和int类型相加，顿悟。改为arr[x][y]
}
}
return sum; //书写过程中忘记写返回语句
}
}

复制代码

         注意 int[ ][ ] arr = new int[2][3];
                  System.out.println(arr);    ------->输出结果为 [[@de6ced
                  System.out.println(arr[0]); ------>输出结果为 [[@de7eca    要注意都是内存地址值
                     int[][]  arr = new int[3][];
                     System.out.println(arr);    ------->输出结果为 [[@de6ced
                     System.out.println(arr[0]); ------->输出结果为 null
                  数组为引用数据类型，没有初始化，默认初始化值为 null

帐号		自动登录	找回密码
密码			加入黑马

[其他交流] ”数组“笔记提交专用帖

评分

优秀作者