黑马程序员—JAVA基础—数组

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

1、概念：

           存储同一种数据类型的多个元素的容器。

2、特点：

          每一个元素都有编号，从0开始，最大编号是长度-1。

         编号的专业叫法：索引

3、定义格式：

     A：数据类型[] 数组名;（一般用这个）

     B：数据类型 数组名[];

4、数组的初始化

    A：动态初始化：只给长度，系统给出默认值

       Eg：int[] arr = new int[3];

   B：静态初始化：给出值，系统决定长度

      Eg：int[] arr = new int[]{1,2,3};

     简化版：int[] arr = {1,2,3};

5、Java的内存分配

  A：栈 存储局部变量

  B：堆 存储所有new出来的

  C：方法区(加载.class 文件)

  D：本地方法区(系统相关)

  E：寄存器(CPU使用)

 图解：

注意事项：

   (1)：局部变量 在方法定义中或者方法声明上定义的变量。

   (2)：栈内存和堆内存的区别

        栈：数据使用完毕，就消失。

        堆：每一个new出来的东西都有地址

        每一个变量都有默认值

           byte,short,int,long    0

            float,double         0.0

           char               '\u0000'

          boolean            false

          引用类型          null

         数据使用完毕后，在垃圾回收器空闲的时候回收。

6、数组内存图

     A：一个数组

     B：二个数组

    C：三个数组(两个栈变量指向同一个堆内存)

7、数组的常见操作

    A：遍历

        方式1：

          

 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;

        }

       方式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;

        }

最小值：

 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：反转

public static void reverse(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;

}

8：Java中的参数传递问题

基本类型：形式参数的改变不影响实际参数

引用类型：形式参数的改变直接影响实际参数

Eg：

	
//形式参数是基本类型
class Demo {
	public int sum(int a,int b) {
		return a + b;
	}
}

//形式参数是引用类型
class Student {
	public void show() {
		System.out.println("我爱学习");
	}
}

class StudentDemo {
	//如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。
	public void method(Student s) { //调用的时候，把main方法中的s的地址传递到了这里 Student s = new Student();
		s.show();
	}
}

class ArgsTest {
	public static void main(String[] args) {
		//形式参数是基本类型的调用
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		System.out.println("--------------");
		
		//形式参数是引用类型的调用
		//需求：我要调用StudentDemo类中的method()方法
		StudentDemo sd = new StudentDemo();
		//创建学生对象
		Student s = new Student();
		sd.method(s); //把s的地址给到了这里
	}
}

9：二维数组

(1)：元素是一维数组的数组。

(2)：格式：

A：数据类型[][] 数组名 = new 数据类型[m][n];

B：数据类型[][] 数组名 = new 数据类型[m][];

C：数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};

D：数据类型[][] 数组名 = {{...},{...},{...}};

Eg：

/*

	需求：打印杨辉三角形
	
	1
	1 1	
	1 2 1
	1 3 3 1
	1 4 6 4 1 
	1 5 10 10 5 1

	分析：看这种图像的规律
		A:任何一行的第一列和最后一列都是1
		B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
	
	步骤：
		A:首先定义一个二维数组。行数如果是n，把列数也先定义为n。
		  这个n的数据来自于键盘录入。
		B:给这个二维数组任何一行的第一列和最后一列赋值为1
		C:按照规律给其他元素赋值
			从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
		D:遍历这个二维数组。
*/
<span style="font-family:Arial Black;">import java.util.Scanner;

class Array2Test3 {
	public static void main(String[] args) {
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		
		//这个n的数据来自于键盘录入。
		System.out.println("请输入一个数据：");
		int n = sc.nextInt();
		
		//定义二维数组
		int[][] arr = new int[n][n];
		
		//给这个二维数组任何一行的第一列和最后一列赋值为1
		for(int x=0; x<arr.length; x++) {
			arr[x][0] = 1; //任何一行第1列
			arr[x][x] = 1; //任何一行的最后1列
		}
		
		//按照规律给其他元素赋值
		//从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
		for(int x=2; x<arr.length; x++) {
			//这里如果y<=x是有个小问题的，就是最后一列的问题
			//所以这里要减去1
			//并且y也应该从1开始，因为第一列也是有值了
			for(int y=1; y<=x-1; y++) {
				//每一个数据是它上一行的前一列和它上一行的本列之和。
				arr[x][y] = arr[x-1][y-1] + arr[x-1][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();
		}
		*/
		//注意，内循环的变化必须和曾经讲过的九九乘法表类似
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<=x; y++) {
				System.out.print(arr[x][y]+"\t");
			}
			System.out.println();
		}
	}
}</span>

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------