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

本帖最后由温暖的小白于 2015-5-12 22:45 编辑

本帖为”数组“笔记分享提交专用帖，只能回复有关”数组“的Java笔记，不得回复与活动主题无关的帖子。

回复格式如下：
      笔记内容：**********
      笔记来源：毕向东Java基础视频第*天
      正文：
         **********
添加代码时请选择编辑器上面的”添加代码文字“。

凡是不按要求回复的帖子一律不得加分。

奖惩规则见活动帖：点击查看{活动帖}

勤奋学习，欢乐得分，正在进行中......

枫烬 · 枫烬

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

枫烬 · 枫烬

本帖最后由枫烬于 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传值/传址？

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

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

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

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

heimatai6 · heimatai6

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

大宝剑 · 大宝剑

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

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之父)】

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)+"个房间");
}
}
}
}

复制代码

唐磊 · 唐磊

笔记内容：数组
笔记来源：刘意老实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]; //错误忘了加分号
}
}*/

白羽蘇芳 · 白羽蘇芳

例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。

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

白羽蘇芳 · 白羽蘇芳

例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反转过来打印结果
}
}

复制代码

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

白羽蘇芳 · 白羽蘇芳

笔记内容：数组
笔记来源：黑马程序员_毕向东最新经典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;
}
}

复制代码

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

joe520kay · joe520kay

本帖最后由 joe520kay 于 2015-7-22 14:23 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天正文
正文：
一、数组的定义：
Java的数组要求所有的数组元素具有相同的数据类型。Java语言支持两种语法格式来定义数组：

第一种：int[] arr =newint[2] 或 int arr[] = new int [2]

第二种：静态初始化：int[]arr = new int[]{2,1,4,5} 或 int [] arr ={2,9,7,5}

动态初始化：int [] arr = new int[5]

arr[0] = 90;

arr[1]= 92;

二、数组的操作：

1、获取数组中的元素。通常会用到遍历

int [] arr = new int [3];
for(int x= 0;x<3;x++)
{
System.out.println("arr["+x+"]="+arr[x]+";")
}

复制代码

数组中有一个属性可以直接获取到数组元素个数：length

使用方式：数组名称.length

int []arr = {3,8,7,6,0,4}

复制代码

{

System.out.println("arr["+x+"]="+arr[x]+";")

//求和

sum += arr[x];

}

2、数组的查找

重点介绍折半法查找

代码如下：

package com.joe.arr;
public class ArrTest {
public static void main(String[] args) {
int[] arr = { 2, 12, 18, 27, 35, 40, 53, 69 };
int index = getIndex(arr, 2);
System.out.println("index=" + index);
int index2 = getIndex(arr, 27);
System.out.println("index=" + index);
}
/*
* 折半查找，提高效率，必须保证该数组是有序的数组。
*/
public static int halfSearch(int[] arr, int key) {
int min, max, mid;
min = 0;
max = arr.length - 1;
mid = (max + min) / 2;
while (arr[mid] != key) {
if (arr[mid] > key)
min = mid + 1;
else if (arr[mid] < key)
max = min - 1;
if (min > max)
return -1;
mid = (max + min) / 2;
}
return mid;
}
/*
* 折半的第二种方式
*/
public static int halfSearch_2(int[] arr, int key) {
int min = 0, max = arr.length - 1, mid = 0;
while (min <= max) {
min = (max + min) >> 1;
if (key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
}
return -1;
}
}

复制代码

冷风然 · 冷风然

本帖最后由冷风然于 2015-7-12 00:04 编辑

java基础刘意老师
下面是根据刘老师的视频和超哥的讲解做的总结
2.数组
 数组:就是存储多个同一种类型元素的容器
 好处有索引,方便操作
 格式
 格式一:元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
 例子: int[] arr = new int [5];
 数据类型：基本类型：4类8种.引用类型：类,接口,数组
 左边：int:表示数据的类型。
 []:表示这是一个数组。
 arr:数组的名字
 右边：new:申请内存空间。
 int:表示数据的类型。
 []:表示这是一个数组。
 5:数组的长度。
 System.out.println(arr);会获取地址
 格式二:元素类型[] 数组名 = new 元素类型[]{元素1,元素2......}
 例子:int[] arr = new int[]{1,2,5,3,6};
 格式三:元素类型[] 数组名 ={元素1,元素2......};
 例子:int[] arr = {1,2,5,3,6};
 常见问题
 A:数组越界异常。你访问了不存在的索引。
 ArrayIndexOutOfBoundsException
 B:空指针异常。一个实例(对象)已经不存在了，你还去访问它的内容。
 NullPointerException
 数组遍历
 int[] arr ={1,4,2,5,6,3,8,};
 for (int x = 0;x<arr.length ;x++ )
 {
 System.out.println(arr[x]);
 }
 数组求最大值
 int max = arr[0];
 for (int y = 0;y < arr.length ;y++)
 {
 if (max < arr[y])
 {
 max = arr[y];
 }
 }
 System.out.println(max);
 二维数组：其实就是元素是一个一维数组。
 索引：角标,下标,编号。
 格式：方式1:
 int[][] arr = new int[3][2];
 解释：定义了名称为arr的二维数组
 二维数组中有3个一维数组
 每一个一维数组中有2个元素
 一维数组的名称分别为arr[0], arr[1], arr[2]
 给第一个一维数组1索引位赋值为78写法是：arr[0][1] = 78;
 二维数组定义格式：
 方式1：int[][] arr = new int[3][2];
 规则的矩形。
 方式2：int[][] arr = new int[3][];
 二维数组中有3个一维数组
 每个一维数组都是默认初始化值null
 可以对这个三个一维数组分别进行初始化
 arr[0] = new int[3];
 arr[1] = new int[1];
 arr[2] = new int[2];
 非规则的矩形。
 方式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
练习
 一位数组的遍历和求最大值的主要代码已在上面,下面是数组查找和二维数组遍历的代码

 数组查找
 class ArrayTest
 {
 public static void main(String[] args)
 {
 int [] arr= {4,1,3,5,6,7,8};
 int index=getIndex(arr,2);
 System.out.println("index="+index);
 }
 public static int getIndex(int [] arr,int key)
 {
 for (int x=0;x<arr.length ;x++ )
 {
 if (arr[x]==key)
 {
 return x;
 }
 }
 return -1;
 }
 }
 二维数组的遍历
 class Array2Demo3
 {
 public static void main(String[] args)
 {
 //二维数组的遍历
 int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
 //arr.length 获取二维数组的长度，其实也就是一维数组的个数
 //arr[x].length 获取的是每一个一维数组的长度
 //arr[x][y] 获取的是二维数组的元素
 for(int x=0; x<arr.length; x++)
 {
 for(int y=0; y<arr[x].length; y++)
 {
 System.out.print(arr[x][y]+"\t");
 }
 System.out.println();
 }
 }
 }

我是新生 · 我是新生

我没有专门做数组的笔记,不过我们java基础班第六天就是讲了数组,这是我第6天自己总结的笔记

1.重要的知识点.
2.一些好的习惯或者重要的注意事项.
3.可能出现的面试题.

重要的知识点
1.函数
定义:在类中的一小段具有特定功能的程序
作用:可以提高代码的复用性和维护性
格式:
修饰符返回值类型(没有就写void) 方法名(参数类型1 形式参数1,参数类型2 形式参数2,...)
{
//方法体;
//return 语句;
}
特点:
函数是平级关系,不能嵌套
函数只有被调用才会被执行.
调用方法:
单独调用:一般用于没有返回值,其类型为void的时候
输出调用:System.out.println(方法名());
赋值调用:方法中返回值是什么类型就用什么类型接收.(不要忽略类型自动转换的问题)
结束方式:
关键字return让方法结束
返回值类型是void的方法,return语句可以省略
定义方法的思路:
1.明确有无返回值,类型是什么
2.明确有无参数,类型是什么,数量是多少
2.数组
定义:存储多个同一数据类型的元素的容器
作用:元素会具备索引,方便操作
特点:
可以存储基本数据类型,也可以存储引用数据类型
一个只能存储同一种数据类型
数组的长度一旦定义就固定
格式:
元素类型[] 数组名 = new 元素类型[长度];
直接打印数组:看到数组在内存中的地址值的十六进制表现形式
获取元素格式:
数组名[索引]
定义方式:(以int型数组为例)
int[] arr1 = new int[3];
int[] arr2 = new int[]{1,2,2};
int[] arr3 = {2,5,5};
数组操作的常见问题:
ArrayIndexOutOfBoundsException//索引越界异常
NullPointerException//空指针异常
数组遍历:就是取出数组中的所有元素的操作
特殊情况:
int[] arr = null;
int[] arr = new int[];//长度为0

3.内存
栈:
局部变量
特点:使用完毕自动消失
堆:
new建立出来的实例
全局变量:都有默认初始化值
整型:0
浮点型:0.0
字符型:'\u0000'(空字符)
布尔型:false
引用类型:null
特点:会在变成垃圾后(没有引用指向),被垃圾回收站不定时的回收.
4.二维数组
格式:
数据类型[][] 变量名 = new 数据类型[n][m];
数据类型[][] 变量名 = new 数据类型[n][];
数据类型[][] 变量名 = {{2,5},{6,8},{5,5},{,4,7}};
遍历二维数组:外循环遍历二维数组,得到每一个一维数组,内循环遍历一维数组.
注意事项:数组的长度不要去数,通过数组名.length获取

重要注意事项
1.函数格式,函数是平级关系,在同一个类中不能嵌套,只能并列存在.
2.函数重载
3.数组格式,内存图要会画,然后数组的使用(遍历,求最值,查找)
4.二维数组格式,内存图要会画

可能出现的面试题
函数的重载

黑马和大灰狼 · 黑马和大灰狼

本帖最后由黑马和大灰狼于 2015-7-12 15:50 编辑

笔记内容：数组
         笔记来源：刘意老师Java基础视频第5天+阳哥笔记结合
         正文：
      数组
   (1)数组是存储同一种类型的多个元素的容器。
         (2)好处：数组中的元素会被自动从0开始编号，方便我们获取。
         (3)格式：
            A:int[] arr = new int[3];　// []中的数字是数组的长度，写成arr.length
            B:int arr[] = new int[3];  //这种写法不建议，建议写成上面的那种写法
            C:int[] arr = new int[]{1,2,3};
            D:int[] arr = {1,2,3};//喜欢这种写法，更加简单哦

Java在内存中的存储情况：
java在启动时，一共在内存中开辟了五块空间来进行自己数据的存储。
包括：栈内存，堆内存，（方法区，本地方法区，寄存器）。每片内存区域中处理数据的方式不一样，因此才划分那么细。
栈内存特点：数据使用完毕，会自动释放。记住，凡是局部变量，都在栈内存里。
堆内存：堆里面存放的都是实体，实体包括数组和对象。凡是new创造出来的实体，都是在堆内存中。
特点：
1、堆内存中的每一个实体，都有一个内存地址值。
2、堆内存中的实体是用来封装数据的，而对内存中的实体中的数据都有默认初始化值。这个值依据元素类型而定，int型默认为0，double默认为0.0，float为0.0f，boolean型为false。
3、垃圾回收机制。
//注意点：Null常量只有引用数据类型才能使用。
//如果将一个数组x[]赋值成null，则不知道了堆内存中数据的初始地址，则和对应的实体就没关系了。
//当一个实体在堆内存中没有任何引用所使用时，java虚拟机就视他为垃圾，并会不定时（内存快要满的时候）的启动一个垃圾回收机制，将数组实体在堆内存中清除。

数组的操作：
1、获取数组中的元素，这是数组中最常用到的操作，通常会用到遍历。
2、数组中有个属性，可以直接获取到数组的数组元素的个数。Length
使用方式：数组名称.length
通常情况下，用到数组的时候，都要用到for循环。

/*重要代码1: 遍历并打印数组元素,就是全部打印一遍*/
class Test1 {
public static void main(String[] args) {
int[] arr = {89,34,270,17};
for(int x = 0; x < arr.length; x += 1){
System.out.println("arr[" + x + "] = " + arr[x] + ";");
}
}
}

复制代码

/*重要代码2：比较大小
思路:
1、需要进行比较，并定义变量记录住每次比较后较大的值。
2、对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
如果遍历到的元素大于变量中记录的元素，就用变量该记录住大的值。
3、遍历结果，该变量记录就是最大值。*/
class Test1{
public static void main(String[] args){
int[] arr = {21,89,73,64,4,2,6,3,3};
int max = getMax( arr);
System.out.println("max="+max);
}
public static int getMax(int[] arr){
int maxElement = arr[0];
for(int x=1 ;x<arr.length ;x++){
if(arr[x]> maxElement){
maxElement = arr[x];
}
}
return maxElement;
}
}

复制代码

/*
重要代码2：排序（冒泡排序、选择排序）
思路：
1、首先拿数组第一个元素依次与除其自身外的其他每个元素顺序比较，如果第一个元素大于剩下的某个元
素，就互换内容。
2、经过第一轮比较之后，此时，第一个元素就是数组中最小的元素。然后再拿第二个元素与除第一个元素和
其自身的元素进行比较，如果第二个元素大于剩下的某个元素，就互换内容。此时，第二个元素就是数组中倒数
第二小的元素。
3、依次类推，直到最后一个元素。*/
class Test1{
public static void main(String[] args){
int[] arr = {1,2,5,4,9,100,1000,152,901};
System.out.println("排序前数组");
printArry(arr);
System.out.println("排序后的数组");
selectSortArry(arr);
printArry(arr);
}
public static void selectSortArry(int[] arr){
for (int x=0;x<=arr.length-2 ;x++ ){
for (int y=x+1;y<=arr.length-1;y++ ){
if(arr[x]>arr[y]){
int temper = arr[x];
arr[x] = arr[y];
arr[y] = temper;
}
}
}
}
public static void printArry(int[] arr){
for (int x=0;x<arr.length ;x++ ){
System.out.print(arr[x]+"\t");
}
System.out.println();
}
}

复制代码

//自己改进的排序和遍历打印合并在一起的代码
class Test1{
 public static void main(String[] args){
 int[] arr = {1,2,5,4,9,100,1000,152,901};
 printArry(arr);

 }
 public static void printArry(int[] b){
 for (int x=0 ;x<=b.length-2 ;x++ ){
 for (int y=x+1 ;y<=b.length-1 ;y++ ){
 if (b[x]>b[y]){
 int temper = b[y];
 b[y] = b[x];
 b[x] = temper;
 }
 }
 }
 for (int z=0;z<=b.length-1 ;z++ ){
 System.out.print(b[z]+"\t");
 }
 }
}

//冒泡排序
class ArrayDemo{
public static void main(String[] args) {
int[] arr= {89,34,-270,17,3,100};
System.out.print("排序前数组：" );
printArray(arr);
bubbleSort(arr);
System.out.print("排序后数组：" );
printArray(arr);
}
public static void bubbleSort(int[] arr){
for(int x = 0; x < arr.length - 1; x++){
for(int y = 0; y < arr.length - 1 -x; y++){
if(arr[y] > arr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = 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] + "]" );
}
}
}

复制代码

Jackron · Jackron

笔记内容：数组笔记来源：刘意java视频第5天
内容:上课的时候，超哥给补充部分内容。

Day05
函数的定义和应用

**定义函数，return返回值**
class function1
{
public static void main(String[] args)
{
 System.out.println(compare(2,4));

}
/*public static boolean eque(int a , int b)
{
if (a==b)
{
return true;
}
}
else
{
return false;
}*/
public static boolean compare(int a , int b)
{
return a==b;

}
}
***重载***
在一个类中，函数名相同，但参数列表不同（包括个数和参数类型），与返回值无关。
***数组***
定义：存储多个元素的容器
格式：元素类型[] 数组名=new 元素类型[元素长度或个数]；
Int[] arr =new int [5]; 另一形式：int arr[] =new int[5]
Int[] arr ={1,2,23,3} Int[] arr =new int [] {1,2,23,3}
;左边：
Int：数据类型
[]:表示是一个数组
Arr：数组名
右边
New：申请内存空间
Int：数据类型
[]:表示是一个数组
5：数组长度
System.Out.println(arr)//[I@7f4e——物理地址
System.Out.println(arr[0])
特点：
1、可以存储基本数据类型，也可以存储引用数据类型
2、一个只能存放同一种数据类型
3、数组的长度固定
**JAVA中对内存**
堆：所有new出来的
栈：变量，或者方法的执行
New出来的实例都存在堆内存里，每一个新new出来的东西都有一个地址值
栈：局部变量：定义在方法中或者方法声明上的形式参数都叫局部变量
当数据使用完毕，就自动从内存中释放。
Null在内存中没有空间没有对象；
多个数组指向同一个堆内存：
例：
class ArrayTest
{
public static void main(String[] args)
{
//定义一个数组
int[] arr=new int [3];
arr[0]=1;
arr[1]=3;
arr[2]=5;
//再定义一个数组
int[] arr2 =arr;
arr2[1]=10;

System.out.println(arr[1]);
System.out.println(arr2[2]);
}
}
练习2：遍历小程序
class ArrayTest
{
public static void main(String[] args)
{
//定义一个数组

//数组遍历
/*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]);*/
/*for (int x=0;x<5 ;x++ )
{
//输出012345
System.out.println(arr[x]);
}*/
/* for (int x=0;x<arr.length ;x++ )
{
//输出012345
System.out.println(arr[x]);
}*/
int[] arr={1,2,3,4,5};
printArray(arr);
}
public static void printArray(int [] arr)
{
for (int x=0;x<arr.length ;x++ )
{
//输出012345
System.out.println(arr[x]);
}
}
}
练习3：遍历获取最大值：

二维数组就是元素是一个一位数组。

3代表3个数组，2代表一个数组中有两个元素；

***数组查找***
class ArrayTest
{
public static void main(String[] args)
{
int [] arr= {4,1,3,5,6,7,8};
int index=getIndex(arr,2);
System.out.println("index="+index);
}
public static int getIndex(int [] arr,int key)
{
for (int x=0;x<arr.length ;x++ )
{
if (arr[x]==key)
{
return x;
}

}
return -1;

}
}
练习4：一维数组倒序遍历
class ArrayTest
{
public static void main(String[] args)
{
int [] arr= {4,1,3,5,6,7,8};
getIndex(arr);

}
public static void getIndex(int [] arr)
{
for (int x=arr.length-1;x>0 ;x--)
{

System.out.println(arr[x]);

}
}
}
练习5：**二维数组遍历**

注：外循环遍历二维数组的每一维数组，内循环遍历一维数组的每个元素。
***二维数组的应用***

class ArrayTest
{
public static void main(String[] args)
{
//二维数组
int [][] arr= {{10,9,8},{16,23,32},{67,112,223},{123,2}};
//每个季度的销售额和年总销售额
int sum=0;

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

sum1+=arr[x][y];
sum+=arr[x][y];

}
System.out.println("第"+(x+1)+"季度的销售额："+sum1);
}
System.out.println("年销售额："+sum);
}

}

xxpotato · xxpotato

笔记内容：数组
笔记来源：毕向东Java基础视频第4天：
正文：
1.函数的定义:
定义：定义在类中，具有特定功能的一小段程序.
2.函数的格式：
格式：
 修饰符返回值函数名（参数类型1 形式参数1，参数类型2，形式参数2 ）
 {
 //方法体
 //return 语句
 }
练习1：
/*
需求：请写一个功能，实现求两个int数中的最大值，
 把最大值返回，并在main方法中进行调用
思路：有返回值吗？有，最大值，int
 有参数吗？有，两个，int，int
*/
class D5HW1
{
public static void main(String[] args)
{
System.out.println(max(3,4));
System.out.println(max(5,4));
System.out.println(max(3,3));
}
public static int max(int a,int b)
{
return a>b?a:b;
}
}

练习2：
/*需求：请编写一个函数完成比较两个int类型数据
是否相等的功能
 思路：1.有返回值吗？有，boolean
 2.有参数吗？有，两个，int，int
 */
class D5HW2
{
public static void main(String[] args)
{
System.out.println(compare(3,3));
System.out.println(compare(3,4));
}
public static boolean compare(int a,int b)
{
return a==b;
}
}

练习3：
/*
需求：根据给定的行数和列数输出组成一个*组成的长方形
（定义一个功能，在主函数中调用）
思路：1.有返回值吗？没有，void
 2.有参数吗？有，两个，行数和列数，int，int
*/
class D5HW3
{
public static void main(String[] args)
{
cfx(3,4);
System.out.println("-------");
cfx(5,6);
}
public static void cfx(int a,int b)
{
for (int x=1;x<=a ;x++ )
{
for (int y=1;y<=b ;y++ )
{
System.out.print("*");
}
System.out.println();
}
}
}

3.函数重载的定义：
 重载是发生在通一个类里面（1分），函数名一样，参数列表不同（个数\ 类型 \ 顺序）（1分），与返回值类型无关，这就是方法的重载。
练习4：

答：B
4.一维数组的定义：
数组：就是存储多个同一种数据类型元素的容器。
5.定义数组的4种方式（掌握）：
int[] arr=new int[5];//必须掌握
-- 变形（int arr1[]=new int[5]//不推荐使用，认识即可，想使用数组的引用，用arr1）
int[] arr2={1,2,3,4,5};//要求数据是什么都要明确
int[] arr3=new int[]{1,2,3,4,5};//理解
练习5：这个程序的输出结果是？

答：10,5
6.一维数组操作（遍历，最值，查找）：
练习6：（**第一遍敲的不熟）
一维数组{1,2,3,4,5,6,7,8,9,0}的遍历。
/*需求：一维数组{1,2,3,4,5,6,7,8,9,0}的遍历。
 思路：1.有返回值吗？没有。
 2.有参数吗？有，一维数组，arr
*/
class D5HW4
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5,6,7,8,9,0};
bianLi(arr);
}
public static void bianLi(int[] arr)
{
for (int x=0;x<arr.length;x++)
{
System.out.print(arr[x]+" ");
}
System.out.println();
}
}

注;不要数有多少个元素，要使用arr.length。
练习7：
一维数组{1,2,3,4,5,6,7,8,9,0}的最值。

j420984 · j420984

笔记内容：常用数组操作
 笔记来源：毕向东Java基础视频第四天
 正文：
 常用数组操作。

遍历

public classLeanr {

public static void main(String args[]) {

 int[]x = { 3, 2, 3, 6, 3, 8,3, 63, 6 };

 for (inti = 0; i < x.length; i++) {

 System.out.print(x[i]+"\n");

 }

}

}

获取最值

public static int getMax(int[]arr) {

 int max = arr[0];

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

 if (arr[i] >max)

 max = arr[i];

 }

 returnmax;

}

public static int getMin(int[]arr) {

 int min = arr[0];

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

 if (arr[i] >min)

 min = arr[i];

 }

 returnmin;

}

如int max=0比较时须将max设为脚标值

选择排序

public static void selectSort(int[]arr) {

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

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

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

 arr[i] =arr[i] ^ arr[j];

 arr[j] =arr[i] ^ arr[j];

 arr[i] =arr[i] ^ arr[j];

 }

 }

 }

}

冒泡排序

public static void bubbleSort(int[]arr) {

 for (inti = 0; i < arr.length; i++) {//for(int i = arr.length-1;x 〉 0；x--)

 for (intj = 0; j < arr.length - i - 1; j++) {//for(int y=0;y<x:y++)

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

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

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

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

 }

 }

 }

}

折半查找

public static int halfSearch(int[]arr, intkey) {

 int min, max, mid;

 min = 0;

 max = arr.length - 1;

 mid = (max +min) / 2;

 while (arr[mid] !=key) {

 if (key >arr[mid])

 min = mid + 1;

 else if (key < arr[mid])

 max = mid - 1;

 if (min >max)

 return -1;

 mid = (max +min) / 2;

 }

 returnmid;

}

IT黑马 · IT黑马

我想说，我是来学习笔记的

温暖的小白 · 13820056923

本帖最后由 13820056923 于 2015-6-21 22:49 编辑

笔记内容：数组
笔记来源：毕向东Java基础视频第4天和教材
正文：
1.数组的定义：
在Java中可以使用以下格式来定义一个数组：int[] x=new int[100]。
相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，以此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
也可以将代码分成两句来写：int[] x; x=new int[100]; 第一行代码int[] x声明了变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。第二行代码x=new int[100],创建了一个数组，将数组的地址赋值给变量x。这时内存中的状态会发生变化。

当数组被成功创建后，数组中元素会被自动赋予一个默认值，根据元素类型的不同，默认初始化的值也是不一样的。

数组的静态初始化有两种方式，类型[] 数组名=new 类型[]{元素，元素，......};类型[] 数组名={元素，元素，元素，......};
千万不可写成int[] x=new int[4]{1,2,3,4};，这样写编译器会报错，原因在于编译器会认为数组限定的元素个数[4]与实际存储的元素{1,2,3,4}个数有可能不一致，存在一定的安全隐患。
2.数组的常见操作
1）数组遍历

public class Example
{
public static void main(String[] args)
{
int[] arr={1,2,3,4,5};//定义数组
//使用for循环遍历数组的元素
for(int i=0;i<arr.length;i++)
{
System.out.println(arr);
}
}
}

复制代码

2）数组最值

public class Example
{
public static void main(String[] args)
{
int[] arr={4,1,6,3,9,8};//定义一个数组
int max=getMax(arr);//调用获取元素最大值的方法
System.out.println("max="+max);//打印最大值
}
static int getMax(int[] arr)
{
int max=arr[0];//定义变量max用于记住最大数，首先假设第一个元素为最大值
//下面通过一个for循环遍历数组中的元素
for(int x=1;x<arr.length;x++)
{
if(arr[x]>max)//比较arr[x]的值是否大于max
{
max=arr[x];//条件成立，讲arr[x]的值赋给max
}
}
return max;//返回最大值max
}
}

复制代码

3）数组排序

public class Example
{
public static void main(String[] args)
{
int[] arr={9,8,3,5,2};
System.out.print("冒泡排序前：");
printArray(arr);//打印数组元素
bubbleSort(arr);//调用排序方法
System.out.print("冒泡排序后：");
printArray(arr);
}
//定义打印数组方法
public static void printArray(int[] arr)
{
//循环遍历数组的元素
for(int i=0;i<arr.length;i++)
{
Syestem.out.print(arr+" ");//打印元素和空格
}
System.out.print("\n");
}
//定义对数组排序的方法
public static void bubbleSort(int[] arr)
{
//定义外层循环
for(int i=0;i<arr.length-1;i++)
//定义内层循环
for (int j=0;j<arr.length-i-1 ; j++)
{
if(arr[j]>arr[j+1])//比较相邻元素
}
//下面的三行代码用于交换两个元素
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
System.out.print("第”+(i+1)+"轮排序后：")；
printArray(arr);
}
}

复制代码

3.多维数组
第一种方式：int[][] arr=new int[3][4]
上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，每个二维数组中的元素又是一个长度为4的数组
第二种方式：int[][] arr=new int[3][]
第二种方法和第一种类似，只是数组中每个元素的长度不确定
第三种方法：int[][] arr={{1,2},{3,4,5,6},{7,8,9}}
上面的二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2},{3,4,5,6},{7,8,9}

qq2403956244 · qq2403956244

本帖最后由 qq2403956244 于 2015-6-21 00:01 编辑

2.【杨辉三角】

/*
二位数组的应用：【杨辉三角】
1 * * * * * 1
1 1 * * * * 1 1
1 2 1 ————> * * * 1 2 1
1 3 3 1 * * 1 3 3 1
1 4 6 4 1 * 1 4 6 4 1
1 5 10 10 5 1 1 5 10 10 5 1
思路：
a.定义一个二维数组存储需要打印的元素。
b.固定每一行第一个数值为1，后面紧接着的数值为上一行的两个数值的和，
然后赋给该行数值在数组中的位置，最后打印数组中的值。
如：上一行： 1 1 0
该行： 1 1+1 1+0 ————>数组初始化为0
*/
class YangHuiSanJiao
{
public static void sanJiao(int n)
{
int[][] array = new int[n][n];
for(int x=0; x<array.length; x++)//行数
{
for(int y=x; y<array.length-1; y++)
{
System.out.print(" ");
}
for(int z=0; z<=x; z++)
{
if(z==0)
{
array[x][z] = 1; //每一行第一个值
System.out.print(array[x][z]+" ");
}
else
{
array[x][z] = array[x-1][z-1]+array[x-1][z];
System.out.print(array[x][z]+" ");
}
}
System.out.println(); //打印一行后换2行
System.out.println();
}
}
public static void main(String[] args)
{
sanJiao(7); //打印7行
}
}

复制代码

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

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

50 个回复

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

浏览过的版块

黑马土豪金

优秀版主勋章

优秀作者

黑马骑士勋章