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

白羽蘇芳 · 白羽蘇芳

笔记内容：数组
笔记来源：黑马程序员_毕向东最新经典Java基础视频day04
正文：
1、数组的定义

概念：
同一种类型数据的集合。数组就是一个容器。

数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 比如
int[] arr = new int[3];
格式2：
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = new int[]{3,6,1,7,8}
int[] arr = {3,6,1,7,8}

2、内存的结构

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

内存的划分：方法区、本地方法区、寄存器。栈内存、堆内存。

栈内存：
·用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
// for（int x =1，x<5,x++）這里的x就是放在栈内存中，for循环一结束，就释放掉了。

堆内存：
·数组和对象，通过new建立的实例都存放在堆内存中。
//new出来的实体不会消失，除非设置为null之后，才会被jvm当作垃圾回收。

· 每一个实体都有内存地址值。
/*
int[] x = new int [1,2,3,4,5]
int[] y = new int [1,2,3,4,5]
這里x与y指向的是两个数组，虽然他们数据相同，但是两个数组有2个内存地址。
*/

·实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean 是false，char类型是'\u0000'。
/*
int[] x = new int [3]
System.out.println(arr[0]);
System.out.println(arr[1]);
打印结果都是0，因为int类型默认初始值为0；
*/

·如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。
/*
int[] x = new int [3]
x = null；
null了这个实体就变成垃圾了，JVM会在个神秘的时间把它干掉
*/

例1：

class ArrDemo
{
public static void main(String[] args)
{
int[] x = new int [3]; //栈内存里变量x，堆内存里创立包含3个角标的数组；
int[] y = x; //栈内存里变量y和x共同指向那个数组；
y[1] = 39; //y把1号角标的数据变更为39；
System.out.println(x[1]);//x回来取出1角标的数据，因为被更改了，所以打印出来39；
}
}

复制代码

结果为：

那么如果是这种情况呢
int a=5;
int b=a;
b=8;
System.out.println(a);

结果a是几？肯定是5啊读一遍看看
5赋值给a
a赋值给b，所以b=5
8赋值给b，所以b=8
打印a，a不还是5么。和例1一对比，這就是栈内存和堆内存的区别。

3、常见问题
例2：

class ArrayDemo{
public static void main(String[] args){
int[] arr = new int[3];
System. out.println(arr[3]);//这个数组只包括arr
}
}

复制代码

new出来的数组只包括arr[0] arr[1] arr[2]，你打印个arr[3]，它当然找不到了
数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。

例3：

class ArrayDemo{
public static void main(String[] args){
int[] arr = null;
System. out.println(arr[0]);
}
}

复制代码

空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。

4、常见操作
数组的操作：
获取数组中的元素，通常会用到遍历。
数组中有个属性，可以直接获取到数组中的元素个数：length
用法：数组名称.length
例4：

/*
遍历数组
*/
class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
System.out.println("length="+arr.length);
for (int x = 0; x<arr.length ; x++ )
{
System.out.println("arr["+x+"]="+arr[x]+";");
}
}
}

复制代码

引申下，如果要得出数组所有元素的和呢？用累加思想

int sum = 0;for (int x = 0; x<arr.length;x++);{sum += arr[x];}

复制代码

再引申下，定义一个功能打印数组并且用逗号隔开

class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
printArray(arr);
}
public static void printArray (int[] arr)
{
for (int x = 0; x<arr.length ; x++ )
{
System.out.print(arr[x]+",");
}
}
}

复制代码

后面多一个逗号，不爽，搞掉他。

class ArrayDemo1
{
public static void main(String[] args)
{
int[] arr = {3,6,5,1,8,9,67};
printArray(arr);
}
public static void printArray (int[] arr)
{
for (int x = 0; x<arr.length ; x++ ) //前面都一样，for里面嵌套个if语句
{
if (x<arr.length-1)
//总共有7个，最后一个是arr[6]，让x<6的时候才打印逗号
System.out.print(arr[x]+",");
else
System.out.println(arr[x]);
}
}
}

复制代码

如果直接System.out.print(arr);那么结果就是

[表示的是数组
I表示的是int
@de6ced表示的是這个数组初始地址的hash值。

例5：给定一个数组{5,1,6,4,2,8,9},获取最大值与最小值。

/*
给定一个数组{5,1,6,4,2,8,9},获取最大值与最小值。
思路：
1，定义个变量，把arr[0]赋值给他
2，让数组中每个数都跟变量比较，比他大就赋值给他
3，定义个函数，两个明确
返回结果是最大值，是个值，所以是int
参数内容，是个数组。
*/
class ArrayTest
{
public static void main(String[] args)
{
int[] arr = new int[]{5,1,6,4,2,8,9};
int max = getMax(arr);
int min = getMin(arr);
System.out.println("max="+max);
System.out.println("min="+min);
}
public static int getMax(int[] arr) //将arr放到函数里来
{
int max = arr[0]; //把0角标的数先赋给max
for (int x = 1 ; x<arr.length; x++ )
{
if (arr[x]>max) //如果arr[1]大于max，就把值赋给max，通过for循环遍历arr[x]
max = arr[x];
}
return max; //将max返回给函数
}
public static int getMin(int[] arr)
{
int min = arr[0];
for (int x = 1 ; x<arr.length; x++ )
{
if (arr[x]<min)
min = arr[x];
}
return min;
}
}

复制代码

------------------------------------------------------
第一次写帖子居然说超字节了= =，分层发吧

白羽蘇芳 · 白羽蘇芳

例6：对给定数组进行排序{5,1,6,4,2,8,9}
方法一：选择排序，思路是arr[0]分别与后面的数比较，碰到小的就让小的到前面来，最后最小的肯定在arr[0]的位置上，然后让arr[1]与后面的比，如此循环，得到排序。

class ArrayTest2
{
public static void selectSort (int[] arr) //定义一个排序的函数
{
for (int x = 0 ; x<arr.length ;x++ )
{
for (int y = x+1;y<arr.length ; y++ )
if (arr[x]>arr[y]) //如果前面的数比后面的数要大
{
int temp = arr[x]; //前面的数放进变量储存起来
arr[x] = arr[y]; //后面的数小，放到前面去
arr[y] = temp; //变量里的数取出来放到后面去
}
}
return;
}
public static void printArr(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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr ={5,1,6,4,2,8,9};
selectSort(arr);
printArr(arr);
}}

复制代码

方法二：冒泡排序
思路：让arr[0]与arr[1]，arr[1]与arr[2]这种相邻2个数比较，大的去后面，在最后的就是最大的数了，循环上述过程，不过第二次只需要循环到倒数第二位，如此循环即可排序

/*
{5,1,6,4,2,8,9} 冒泡排序
*/
class ArrayTest3
{
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++ ）
// -x：让每次比较的数变少，-1：为了不让y+1那个角标越界
{
if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
public static void printArr(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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
bubbleSort(arr);
printArr(arr);
}
}

复制代码

实际开发时，上面什么选择排序、冒泡排序统统不用，java提供了API供我们调用

import java.util.*;
/*
{5,1,6,4,2,8,9} 冒泡排序
*/
class ArrayTest3
{
public static void printArr(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.print(arr[x]+"]");
}
}
public static void main(String[] args)
{
int[] arr = {5,1,6,4,2,8,9};
Arrays.sort(arr);
printArr(arr);
}
}

复制代码

实际开发中，2句紫色的语句，就搞定了。

在上面两种排序方法中，有个部分是重复的，都是通过定义第三方变量来实现数组中两个数据的位置互换。那么我们可以定义一个函数来实现这个功能。

public static void swap(int[] arr,int a,int b){ int temp = int a; int a = int b; int b = temp;
}

复制代码

有了个东西，像冒泡排序的這一段

if (arr[y]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}

复制代码

就可以写成

if (arr[y]>arr[y+1] swap (arr,y,y+1);

复制代码

就搞定了。

例7：遍历查找

/*
遍历查找{3,1,5,4,2,9}
*/
class ArrayTest4
{
public static int getIndex(int[] arr,int key)
{
for (int x=0 ; x<arr.length ;x++ ) //角标从0开始自增到角标最大值
{
if (arr[x]==key) //如果找到了指定的值
return x; //返回此值的角标给函数以供调用
}
return -1; //找不到，说明数组中没有，返回个-1
}
public static void main(String[] args)
{
int[] arr = {3,1,5,4,2,9};
int Index = getIndex(arr,2);
System.out.println("Index="+Index);
}
}

复制代码

无序数组可以通过遍历查找。如果是有序数组，那么还有更高效的方法：折半查找。

例8：折半查找
方法一：以key是否等于arr[mid]为条件进行循环，直到找到目标为止。

/*
折半查找能提高效率，但要保证是有序排列的数组
*/
class ArrayTest5
{
public static void main(String[] args)
{
int[] arr = {2,4,5,7,19,32,45};
int Index = halfSearch(arr,32);
System.out.println("Index="+Index);
}
public static int halfSearch(int[]arr,int key)
{
int min=0;
int max=arr.length-1;
int mid=(min+max)>>1; //右移1就是除2的1次方，复习一下
while (key!=arr[mid]) //当key不等于中间角标的数时，
{
if (key<arr[mid]) //如果key小于中间的数
max = mid-1; //最大角标mid-1
else if (key>arr[mid])//否则如果key大于中间的数
min = mid+1; //最小角标为mid+1
if (min>max) //如果min大于max了，说明数组不存在key
return -1; //返回-1
mid = (max+min)/2;
//min或max改变一次后，缩小了一半的范围，重置下mid，继续循环查找key
}
return mid; //直到找到了key，跳出循环
}
}

复制代码

方法二：以min<=max为循环条件，一直减半查找，直到找到目标。

/*
折半查找能提高效率，但要保证是有序排列的数组
*/
class ArrayTest5
{
public static void main(String[] args)
{
int[] arr = {2,4,5,7,19,32,45};
int Index = halfSearch(arr,32);
System.out.println("Index="+Index);
}
public static int halfSearch(int[]arr,int key)
{
int min = 0,max = arr.length-1,mid;
mid = (min+max)>>1;
while (min<=max)
{
mid = (min+max)>>1;
if (key<arr[mid])
max = mid-1;
else if (key>arr[mid])
min = mid+1;
else
return mid;
}
return -1;
}
}

复制代码

方法一和方法二的结果自然都是一样的。
那么引申下，如果要往数组中插入个8呢，往哪插？
只需上面的return mid改成return min即可。为什么？
{2,4,5,7,19,32,45}插入8，以方法二为例，
min = 0 ，max = 6，mid=（0+6）/2=3，
arr[3]=7，key>arr[3], min=mid+1;
8是不是就是插在7后面的一个位置啊，那就是min了呗，返还给函数即可

学了数组和函数，现在用学过的只是再来见一下老朋友，进制转换。

例9：十进制转二进制

class ArrayTest6
{
public static void main(String[] args)
{
toBin(6);
}
public static void toBin(int num)
{
while (num>0)
{
System.out.println(num%2); //二进制就是一个数模2的结果，一个数除2不是0就是1
num = num/2; //模2后再除2，继续循环
}
}
}

复制代码

6的二进制是110，出来了，看着不太爽，改一下

class ArrayTest6
{
public static void main(String[] args)
{
toBin(6);
}
public static void toBin(int num)
{
StringBuffer sb = new StringBuffer(); //建立个对象用来装东西
while (num>0)
{
//System.out.println(num%2); 不打印了，将模2的结果装进容器里
sb.append(num%2); //将模2的结果装到sb里去,从尾数往里装，结果是反的啊
num = num/2;
}
System.out.println(sb.reverse()); //reverse反转过来打印结果
}
}

复制代码

哦了
-------------------------------------------------------------
我是不是太话痨了。。笔记应该言简意赅？居然还超字节。。。话说不会被认为在灌水吧=，=

白羽蘇芳 · 白羽蘇芳

例10：十进制转十六进制

class ArrayTest7
{
public static void main(String[] args)
{
toHex(60);
}
public static void toHex(int num)
{
StringBuffer sb = new StringBuffer();
for (int x = 0; x<8 ; x++ )
{
int temp = num & 15; //与个15，取出二进制的最后4位存进变量
if (temp>9)
sb.append((char)(temp-10+'A')); //大于9,16进制是字母，转换成字母
else
sb.append(temp); //小于9的直接存起来
num = num>>>4; //右移4位，继续循环
}
System.out.println(sb.reverse()); //反转打印
}
}

复制代码

查表法
将所有元素临时储存起来，建立对应关系，根据运算结果作为角标去查建好的表，取出对应的元素，就叫查表法
以十进制转十六进制为例：

num & 15,得出的是num二进制的最后四位，将这四位数转换成十六进制的字符就是最后一位了。
然后把num右移4位，继续&15，得出的后四位就是十六进制的倒数第二位。
以此循环，直到右移4位之后，num剩下的全是0了，就不用再运算了

相同的道理，
十进制转二进制就是&1再右移1
十进制转八进制就是&7再右移3 这个不懂的，回去看看第二篇文章进制那地方。

例11：求十进制整数的二进制、八进制、十六进制的表现形式

class ArrayDemo
{
public static void main(String[] args)
{
toHex(60);
toBin(-6);
}
//十进制-->二进制
public static void toBin(int num) {
trans(num,1,1);
}
//十进制-->十六进制
public static void toHex(int num) {
trans(num,15,4);
}
//十进制-->八进制
public static void toOctal(int num){
trans(num,7,3);
}
//进制转换的通用方法
public static void trans(int num, int base,int offset) //base就是&的数，offset就是右移的数
{
if(num == 0)
{
System.out.println("0" ); //当num=0了，就返回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) //num只要还不为0
{
int temp = num & base; //就执行&操作，得出所求进制的最后一位
arr[--pos] = chs[temp]; //到chs里找到对应的符号，赋值到数组arr中的最后1,2,3...位
num = num >>> offset; //右移
}
System.out.println("pos = " + pos); //这里得出的是有效数字，前面都是0或者负数的话就是1了
for(int x = pos; x < arr.length; x++) //比如十六进制arr长度是8个，角标0~7
{ //pos是有效位，如果是3，那么打印的就是arr[5][6][7]
System.out.print(arr[x]);
}
System.out.println();
}
}

复制代码

当然就跟排序似的，真实开发中不会让干這么恶心的事，有API呢，直接调用就搞定了，

class ArrayDemo
{
public static void main(String[] args)
{
System.out.println(Integer.toHexString(60));
}
}

复制代码

5、二维数组
二维数组就是数组中的数组。
格式一：int[][]arr = new int [3][2]
定义了一个二维数组，名称为arr
二维数组中有3个一维数组
3个一维数组的名称为arr[0] arr[1] arr[2]
每个一维数组中有2个元素
给第一个一维数组中的角标1的元素赋值为 int[0][1]=78;

格式二：int[][]arr = new int [3][]
这个二维数组中有3个一维数组
每个一维数组的初始化值都是null
可以分别对一维数组进行初始化：
arr[0] = new int [3];

例12：打印二维数组的和

/*
打印二维数组{{3,5,1,7},{2,3,5,8}{6,1,8,2}}
*/
class Arr2Demo
{
public static void main(String[] args)
{
int[][]arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};
int sum=0;
for (int x = 0; x<arr.length ; x++ ) //把每个一维数组加起来
{
for (int y = 0 ;y<arr[x].length ; y++ ) //求单个一维数组的和
{
sum = arr[x][y]+sum;
}
}
System.out.println("sum="+sum);
}
}

复制代码

练习：
定义  int[] x,y[]，以下选项可不可以成立。
a. x[0]=y;
b. y[0]=x;
c. y[0][0]=x;
d. x[0][0]=y;
e. y[0][0]=x[0];
f. x=y

回顾一下：
定义一维数组可以是：int[] x ,int x[];
定义二维数组可以是：int[][]  y, int  y[][],    int[]  y[];
那么题设中的 int[]  x,y[]什么意思呢，拆解开来就是
int[] x;
int[] y[];
定义了一个一维数组x，定义了一个二维数组y。

这样选项就很容易判断了：
a. x[0]=y;             左边是一维数组中的一个值，右边是个二维数组， error。
b. y[0]=x;             两边都是一维数组，yes。
c. y[0][0]=x;       左边是一个值，右边是一维数组，error
d. x[0][0]=y;          x根本就不是二维数组，左边就写错了，error
e. y[0][0]=x[0];    左边是一个元素，右边也是一个元素，yes
f. x=y                   左边一维数组，右边二维数组，error。

---------------------------------------------------------------------------------------
终于写完了

唐磊 · 唐磊

笔记内容：数组
笔记来源：刘意老实Java基础视频第4天
正文格式：
数组格式
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];通过new关键字创建了一个长度为5，元素类型是int的数组实体,并把这个数组实体赋值给引用类型变量 arr, 所以arr的类型是int[] (int类型数组)
会打印数组的内存地址（暂且这样记忆，之后会详细讲解），可以通过索引获取指定位置的元素

int [] arr = new int[5];

数据类型：
　基本类型；４类８种。
引用类型；类，借口，数组。

左边；
int；表示数据类型。
[]；表示这是一个数组
arr；数组的名字。

右边；
new;
int;表示数据类型。
[]；表示一个数组
5；数组的长度

其他三种数组格式 A int[] arr =new int[2];//念法:int类型的数组arr
 B int arr[] = new int[2];//念法:int 类型的arr数组,不推荐这么写,他和第一种格式其实一样的
 C int[] arr = new int[]{1,2,3,7};//大括号内可以没有任何东西
 D int[] arr = {3,4,65,4};//大括号内可以没有任何东西

 System.out.println(arr2) 是打印 arr2的十六进制字符
System.out.println(arr[2]) 是打印堆中角标为3的元素

class Demo
{
public static void main(String[] args)
{
double[] arr1 = new double[2];
int[] arr2 = new int[2]; //arr1 arr2 arr3就相当于变量x y z
char[] arr3 = new char[3]; //
boolean[] arr4 = new boolean[3];
System.out.println(arr2);
}

}*/

/*
需求：我要获取一个数据肿么办？
通过索引（类似于字典的索引）。格式：数组名【索引】
arr[0] arr[1]

Java内存图：
A:栈存储局部变量使用。局部变量：定义在方法中或者方法声明上的形式参数都叫做局部变量
使用完毕，立马消失。

B:堆所有new出来的都在堆里面。
a:每一个实体都有地址值 本身是十进制，显示的是十六进制
b:每一个实体内的内容都有默认值
整数：0
浮点数：0.0
字符：'\u0000'
布尔：false
c:实体不再被使用的时候，在垃圾回收器空闲的时候被回收。

C:方法区
D:本地方法区
E:寄存器

需求：我要给第三个元素赋值为10，肿么办？
arr[2]=10; 我说过了 arr[] 就相当于一个变量，[]里面装的是角标

****知识点：数组操作的常见问题

A 数组越界 访问了不存在的索引,如下
ArrayIndexOutOfBoundsException

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,2};

System.out.println(arr[3]);
System.out.println(arr[5]);//没有角标6的元素
}

}
B 空指针异常。一个实例对象都已经不存在了，你还要访问
NullPointerException

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,2};

arr=null; //重新给arr赋值，以前是堆的地址值赋值给arr,
现在是null赋值给arr,arr就不会通过地址值指向堆

System.out.println(arr[3]); //arr 已经是个空的了
}

}
/*
知识点；多个数组指向同一个实例

class Demo
{
public static void main(String[] args)
{
int[] arr=new int[3];
arr[0]=1;
arr[1]=3;
arr[2]=5;

int[] arr2=arr; //再定义一个数组，把数组arr的值（地址值）付给了arr2
arr2[1]=10;

System.out.println(arr[1]);//10

System.out.println(arr2[2]);//5
}

}
*/
/*
知识点；遍历 获取数组中的所有元素

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
}

}
//通过循环改进，把所有数组中元素罗列出来

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

for (int x=0;x<5;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}

}
//如果数据太多，就没办法了遍历么？？
//假如有人能够提供我们数组的长度，就可以做了(x<?)
// java 提供了一个属性 length
格式；数组名.length
class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}

}

需求；数组遍历 用方法
思路
返回值类型；void
参数列表；int[]arr

class Demo
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};
int[] arr2={34,415,515,321,54,52,37,73,42};
printArray(arr); //执行一遍函数

printArray(arr2); // 再执行一遍函数
}
public static void printArray(int[] arr) // 传送数组 arr无所谓他和上面的arr1 arr2没有联系其实传送的是空，直接就打印出来了 {
for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
System.out.println(arr[x]);
}
}
}

*/
/*
需求，求数组中的最大值
思路
1.需要进行比较，并且定义变量记住每次比较后较大的值
2.对数组中的元素遍历取出，和变量记住的元素进行比较
 如果遍历的元素大于变量中记录的元素，就用变量记住较大的值。
3.遍历结果，该变量记住的就是最大值。

定义一个功能实现

明确1 结果。
是数组中的元素，int
明确2 未知内容
数组

class Demo
{
public static void main(String[] args)
{

int[] arr={34,415,515,321,54,52,37,73,42};

int max = getMax(arr); //先定义，在打印输出，这都错！！MD！！///?????????

System.out.println(max);

}
//方法1 定义元素
public static int getMax(int[] arr)
{ // 传送数组 arr无所谓他和上面的arr1 arr2没有联系 {
int max=arr[5]; //定义 int max=0 就是让每次循环中元素跟0对比，
//假如元素中都是负数，那没就会输出最大值是0
//所以定义max 可以随意定义一个 数组中的任何一个元素

//初始化数组中的 元素可以，那么初始化元素中的角标可不可以呢？怎么可以做到呢
// 可以，因为元素跟角标有着对应关系

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
if (arr[x]>max)
{
max=arr[x]; //每遍历一次数组中的元素都要循环做一次比较
}
}

return max; //错误忘了加分号
}

// 方法2（定义角标）运行方法2的时候需要把int max = getMax(arr);改成int max = getMax2(arr);

public static int getMax2(int[] arr)
{
int maxIndex=0; //初始化定义一个角标也可以，因为角标对应着元素

for (int x=0;x<arr.length;x++) //x定义的是脚标 0 1 2 3 4
{
if (arr[x]>arr[maxIndex]) //元素跟角标对应的元素作对比
{
maxIndex=x; //
}
}

return arr[maxIndex]; //错误忘了加分号
}
}*/

wode1311 · wode1311

本帖最后由 wode1311 于 2015-7-31 22:44 编辑

笔记内容：数组的基础知识和应用
笔记来源：毕向东Java基础视频第5天
正文：
1、基础概念： [url=]

数组是存储多个同一类型数据元素的容器，数组中的元素会被自动从0开始编号，方便我们获取。

分类：

一维数组（4种定义格式）：

int[] arr =new int[2];

int arr[] = new int[2];

int[] arr = new int[]{1,2,3,7}; //大括号内可以没有任何东西

int[] arr = {3,4,65,4}; //大括号内可以没有任何东西
二维数组（三种定义格式）：

第一种定义通过定义长度的方式定义了二维数组的长度，并且定义了一维数组的长度 int[][] arr = new int[6][3]

第二种定义通过长度仅定义了二维数组的长度，没有初始化一维数组int[] [] arr= new int[2][]

第三种定义通过直接给出元素定义了二维数组的长度和每一个一维数组的长度 int[][] arr = {{2,23},{33}}

2、数组操作：

1、数组遍历：

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

System.out.print(arr+"\t");

}

2、获取数组最值
 public int getMax(int[] arr){
 int temp=arr[0];
 for(int i=1;i<arr.length;i++){
 if(arr>temp){
 temp=arr;

 }
 }
 return temp;
 }

3、数组查找：给定一个值，查找该值在数组中对应的索引

public static int indexFirst(int[] arr, int num) {
 for (int i = 0; i < arr.length; i++) {
 if (arr == num) {
 return i;
 }
 }
 return -1;
 }

3、数组应用：

[/url] 1 、利用数组自定义一个可变长度的容器，可存储不同的数据。

import java.util.Scanner;
class Container {
Object[] src;// 存放数据的数组
/** 通过add方法将val添加到容器内 */
public void add(Object val) {
if (src != null) {
Object[] arr1 = new Object[src.length + 1];
for (int i = 0; i < src.length; i++) {
arr1[i] = src[i];
}
arr1[src.length] = val;
src = new Object[arr1.length];
for (int i = 0; i < src.length; i++) {
src[i] = arr1[i];
}
} else {
src = new Object[1];
src[0] = val;
}
}
/** 通过给get方法传递一个索引，可以获取到该索引位置对应的值 */
public Object get(int index) {
return src[index];
}
/** 通过lenth()可以获取该容器中存储了多少个数据 */
public int length() {
return src.length;
}
}
class Contain {
public static void main(String[] args) {
Container c = new Container();
int tip;
Object o;
while (true) {
System.out.println("请输入一个数据(1整型2浮点型3布尔型4字符串0停止)：");
Scanner sc = new Scanner(System.in);
tip = sc.nextInt();
if (tip == 0) {
break;
} else {
o = setContent(tip);
c.add(o);
}
}
for (int i = 0; i < c.length(); i++) {
System.out.println("第" + i + "个数据是:" + c.get(i));
}
System.out.println("共有" + c.length() + "个数据");
}
public static Object setContent(int tip) {
Scanner sc = new Scanner(System.in);
int i;
double d;
boolean b;
String s;
Object o = null;
while (true) {
if (tip == 1) {
i = sc.nextInt();
o = i;
break;
} else if (tip == 2) {
d = sc.nextDouble();
o = d;
break;
} else if (tip == 3) {
b = sc.nextBoolean();
o = b;
break;
} else if (tip == 4) {
s = sc.next().toString();
o = s;
break;
} else {
System.out.println("输入非法数据，请重新输入...");
break;
}
}
return o;
}
}

复制代码

2、数组拷贝，获取数据在数组中的位置，以及从某个位置开始获取某个元素的相对位置

public static void main(String[] args)
{
int[] a=new int[]{1,2,3,4,5,8,5};
int[] b=new int[a.length];
ArrayCopy(a,b);
char[] c=new char[]{'a','b','c','d','e'};
char d='d';
int location=indexOf(c,d);
System.out.println(d+"在字符数组中的位置是第"+(location+1)+"个元素");
char[] arr=new char[]{'1','2','3','4','6','9'};
int position=indexOf(arr,2,'4');
System.out.println("从第二个位置开始,4所在的位置是第"+position+"个元素");
}
//数组拷贝
public static void ArrayCopy(int[] a,int[] b){
for(int i=0;i<a.length;i++){
b[i]=a[i];
}
}
//获取元素位置
public static int indexOf(char[] chs, char ch){
for(int i=0;i<chs.length;i++){
if(chs[i]==ch){
return i;
}
}
return -1;
}
//获取元素的相对位置
public static int indexOf(char[] chs,int startIndex,char ch){
int count=1;
for(int i=startIndex-1;i<chs.length;i++){
if(chs[i]==ch){
return count;
}
count++;
}
return -1;
}

复制代码

3 、房间案例（二维数组）：一栋楼有7层，每层有10个房间，那么就把大楼看成一个二维数组，里面的每层是一维数组。

class RoomDemo
{
public static void main(String[] args)
{
int[][] room = new int[7][10];
for(int i=0; i<room.length; i++)
{
int[] floor = room[i];
for(int j=0; j<floor.length; j++)
{
System.out.println("正在第"+(i+1)+"层中的第"+(j+1)+"个房间");
}
}
}
}

复制代码

jipinxianren · jipinxianren

一、数组【掌握】
1、数组：存储同一种数据类型的多个元素的容器。

2、特点：每一个元素都有一个编号，从0开始，最大编号是数组长度 - 1。
这个编号的专业叫法：索引。

3、格式：
(1)动态初始化
只指定长度，由系统给出初始化值
A:int[] arr = new int[3];
//B:int arr[] = new int[3];

(2)静态初始化
给出初始化值，由系统计算长度
A:int[] arr = {1,2,3};
//B:int[] arr = new int[]{1,2,3};

两种初始化都推荐A方案

4、Java内存图：
A:栈存储局部变量; 方法在栈里面调用(压栈)
局部变量:定义在方法声明上和方法中的变量
方法调用完毕会弹栈，方法内部的局部变量也随之消失。

B:堆所有new出来的都在堆内存里面。
a:每一个对象都有地址值
b:堆内存里面每一个基本数据类型的变量都有默认值
整数：0 byte, short, int
浮点数：0.0 float, double
字符：'\u0000' char
布尔：false boolean

C:方法区（面向对象部分讲解）
D:本地方法区（和系统相关）
E:寄存器（CPU使用）

5、数组内存图
A:一个数组
B:二个数组
C:三个数组(两个栈里面的局部变量指向同一个堆内存)

6、常见操作：【重点掌握】
A:遍历
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}

方式2：
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
} else {
System.out.println(arr[x]+", ");
}
}
}

B:最值
最大值：
public static int getMax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
return max;
}

C:反转
方式1：
public static void reverseArray(int[] arr) {
for(int i=0; i<arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}

方式2：
public static void reverseArray(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}

D:查表
public static String getString(String[] strArray, int index) {
return strArray[index];
}

E:基本查找
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
}

7、二维数组【理解】
格式：
A:int[][] arr = new int[3][2]; //有三个一位数组，每个一维数组里面有2个int元素。
B:int[][] arr = new int[3][];
C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

遍历：
public static void print(int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}

求和：
public static int getSum(int[][] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
sum += arr[i][j]
}
}
return sum;
}

二、参数传递【掌握】
public static void main(String[] args) {
int a = 10;
int b = 20;
change(a, b);
System.out.println("a=" + a + ", b=" + b); //a=10, b=20

int[] arr = {1,2,3,4,5};
change(arr);
System.out.println(arr[1]); //arr[1] = 4;
}

public static void change(int a, int b) {
a = b;
b = a + b;
}

public static void change(int[] arr) {
for(int x=0; x<arr.length; x++) {
if(arr[x]%2 == 0) {
arr[x] *= 2;
}
}
}

结论：
基本数据类型的值传递,不改变原值,因为方法在栈里面调用，调用完毕后方法会弹栈,局部变量也随之消失;
引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问

简单记：
A: 基本数据类型作为方法参数传递时，形参的改变不影响实参;
B：引用数据类型(数组，类，接口)作为参数传递时，形参的改变影响实参。

面试题：Java中到底是传值还是传址
A：既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
B：java中只有传值,因为地址值也是值【出去面试都说这种,支持者是高司令(java之父)】

大宝剑 · 大宝剑

~~~~~~~~~~~~~~

heimatai6 · heimatai6

、、、、、、、、、、、、、、

枫烬 · 枫烬

本帖最后由枫烬于 2015-11-6 00:56 编辑

笔记内容：数组
笔记来源：冯佳Java基础视频第6天
正文：

概述

数组是存储同一种数据类型多个元素的集合/容器，可以存储基本数据类型或是引用数据类型。
数据类型[] 数组名 = new 数据类型[数组长度];

[]的个数代表数组的维度

特点：
- 数组的每个元素都有编号（index，索引，角标），从0开始，最大编号为arr.length-1
- 在堆内存里面是一块连续的内存空间
初始化：不允许动静结合
- 动态初始化，指定长度，系统给出初始化值
- 静态初始化，指定初始化值，系统来决定长度

默认初始化值：

整数类型	byte,short,int,long	0
浮点类型	float，double	0.0
布尔类型	boolean	false
字符类型	char	'\u0000'
引用数据类型		null

‘\u0000’:每个0都是代表16进制的0

Sys.out.print(arr); ==>[I@da6

内存

内存区块：

栈	存储局部变量	先进后出
堆	存储new出来的数组或对象
方法区	存储代码
本地方法区	和系统有关
寄存器	cpu用

局部变量：定义在方法声明和方法体里的变量

类文件运行加载后，主方法main以栈针的形式压栈到栈底，定义数组，在堆创建数组的连续空间

异常
- ArrayIndexOutOfBoundsException 数组索引越界异常
- NullPointerException空指针异常

操作

遍历

//遍历数组
public static void testArray01(int[] arr){
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i]+"\t");
}
System.out.println();
}

复制代码

最大值
1. //获取数组最大值
2. public static void getArrayMax(int[] arr){
3. int max = arr[0];
4. for (int i = 1;i<arr.length ;i++) {
5. if (max < arr[i]) {
6. max = arr[i];
7. }
8. }
9. System.out.println("最大值为："+max+"。");
11. }
复制代码
最小值
1. //获取最小值
2. public static int getArrayMin(int[] arr) {
3. int min = arr[0];
4. for (int i = 1;i <arr.length ;i++ ) {
5. if (min > arr[i]) {
6. min = arr[i];
7. }
8. }
9. return min;
10. }
复制代码
反转
1. //反转
2. public static void reverseArray(int[] arr) {
3. for (int i = 0;i < arr.length/2 ;i++ ) {
4. int temp = arr[i];
5. arr[i] = arr[arr.length-i-1];
6. arr[arr.length-i-1] = temp;
7. }
8. }
复制代码
排序
由值返回角标
1. //由值返回角标
2. public static int getIndex(int[] arr,int value) {
3. for (int i = 0;i < arr.length ;i++) {
4. if (arr[i] == value) {
5. return i;
6. }
7. }
8. return -1;
9. }
10. }
复制代码
由角标返回值
1. //星期
2. public static void getWeek(int week){
3. char[] weekDay = {'一','二','三','四','五','六','日'};
4. System.out.println("这是星期"+weekDay[week-1]+"。");
6. }
复制代码

二维数组

数据类型[ ][ ] 数组名称 = new 数据类型[ a ][ b];

==》a个一维数组，每个一维数组中有b个元素

Int[]x,y[]; x是一维数组，y是二维数组；

默认初始化值是null

参数传递问题：

基本类型数据的值传递，不改变原值，因为调用后会弹栈，局部变量消失。调用时，用的只是将变量的值赋给局部变量。

引用数据类型的值传递，改变原值，因为即使方法弹栈，但堆内存数组对象还在，可通过地址访问

java传值/传址？

只有传值，因为地址值也是值

形参的改变会影响实参吗？

基本数据类型，形参的改变不影响实参

引用数据类型，形参的改变影响实参

枫烬 · 枫烬

我用的onenote做的笔记，复制过来之后格式就难看了==！！！

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

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

评分

评分

评分