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

最新推荐文章于 2024-04-30 17:28:01 发布

LDH2015517

最新推荐文章于 2024-04-30 17:28:01 发布

阅读量250

点赞数

分类专栏：日记文章标签： java 黑马程序员

本文链接：https://blog.csdn.net/qq_16038851/article/details/44309761

版权

日记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------数组，二维数组，对象数组

一：数组
   (1)数组：存储同一种数据类型的多个元素的容器。
   (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。
             编号的专业叫法：索引
   (3)定义格式
       A:数据类型[] 数组名; int [ ] arr ;
       B:数据类型数组名[]; int arr [ ] ;

        注意：推荐是用A方式，B方法就忘了吧。但是要能看懂
   (4)数组的初始化
       A:动态初始化
           只给长度，系统给出默认值

           举例：in t[ ] arr = new in t[3];
       B:静态初始化
           给出值，系统决定长度

           举例：int [ ] arr = new int [ ]{1,2,3};
           简化版：int [] arr = {1,2,3};
   (5)Java的内存分配
       A:栈存储局部变量
       B:堆存储所有new出来的
       C:方法区(面向对象部分详细讲解)
       D:本地方法区(系统相关)
       E:寄存器(CPU使用)

       注意：
           a:局部变量在方法定义中或者方法声明上定义的变量。
           b:栈内存和堆内存的区别
               栈：数据使用完毕，就消失。
               堆：每一个new出来的东西都有地址
                    每一个变量都有默认值
                       byte,short,int,long ：0
                       float,double： 0.0
                       char ：'\u0000'
                       boolean ：false
                       引用类型： null
                    数据使用完毕后，在垃圾回收器空闲的时候回收。
   (6)数组的常见操作
       A:遍历
           方式1：

<span style="font-size:18px;"> public static void printArray(int[] arr) {
                    for(int x=0; x<arr.length; x++) {
                        System.out.println(arr[x]);
                    }
                }</span>

           方式2：

<span style="font-size:18px;"> 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]+", ");
                        }
                    }
                }</span>

       B:最值
           最大值：

<span style="font-size:18px;">  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;
                }</span>

           最小值：

<span style="font-size:18px;"> 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;
                }</span>

       C:逆序
           方式1：

<span style="font-size:18px;"> public static void reverse(int[] arr) {
                    for(int x=0; x<arr.length/2; x++) {
                        int temp = arr[x];
                        arr[x] = arr[arr.length-1-x];
                        arr[arr.length-1-x] = temp;
                    }
                }</span>

           方式2：

<span style="font-size:18px;">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;
                    }
                }</span>

D:查表

<span style="font-size:18px;"> public static String getString(String[] strArray,int index) {
                    return strArray[index];
                }</span>

       E:基本查找
           方式1：

<span style="font-size:18px;">public static int getIndex(int[] arr,int value) {
                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            return x;
                        }
                    }
                    
                    return -1;
                }</span>

           方式2：

<span style="font-size:18px;">  public static int getIndex(int[] arr,int value) {
                    int index = -1;
                
                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            index = x;
                            break;
                        }
                    }
                    
                    return index;
                }</span>

二：二维数组
   (1)元素是一维数组的数组。
   (2)格式：
       A:数据类型[ ][ ] 数组名 = new 数据类型[m][n];
       B:数据类型[ ][ ] 数组名 = new 数据类型[m][];
       C:数据类型[ ][ ] 数组名 = new 数据类型[ ][ ]{{...},{...},{...}};
       D:数据类型[ ][ ] 数组名 = {{...},{...},{...}};
   (3)案例:
       A:二维数组的遍历

<span style="font-size:18px;">class Array2Test {
	public static void main(String[] args) {
		//定义一个二维数组
		int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
		
		printArray2(arr);
	}
	
	
	public static void printArray2(int[][] arr) {
		for(int x=0; x<arr.length; x++) {
			for(int y=0; y<arr[x].length; y++) {
				System.out.print(arr[x][y]+" ");
			}
			System.out.println();
		}
	}
}</span>

B:二维数组的求和

<span style="font-size:18px;">class Array2Test2 {
	public static void main(String[] args) {
		//二维数组
		int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
		
		//定义一个求和变量sum，初始化值是0。
		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);
	}
}</span>

C:杨辉三角形

<span style="font-size:18px;">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++) {
			
			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<=x; y++) {
				System.out.print(arr[x][y]+"\t");
			}
			System.out.println();
		}
	}
}</span>

三: 对象数组
   (1)数组既可以存储基本数据类型，也可以存储引用类型。它存储引用类型的时候的数组就叫对象数组。
   (2)案例：
       用数组存储5个学生对象，并遍历数组

<span style="font-size:18px;">public class ObjectArrayDemo {
	public static void main(String[] args) {
		// 创建学生数组(对象数组)。
		Student[] students = new Student[5];

		// 创建5个学生对象，并赋值。
		Student s1 = new Student("a", 22);
		Student s2 = new Student("b", 20);
		Student s3 = new Student("c", 25);
		Student s4 = new Student("d", 26);
		Student s5 = new Student("e", 30);

		// 把元素放到数组中。
		students[0] = s1;
		students[1] = s2;
		students[2] = s3;
		students[3] = s4;
		students[4] = s5;

		

		// 遍历
		for (int x = 0; x < students.length; x++) {
			//System.out.println(students[x]);
			
			Student s = students[x];
			System.out.println(s.getName()+"---"+s.getAge());
		}
	}
}
</span>

LDH2015517

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员——java基础——数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------数组，二维数组，对象数组一：数组 (1)数组：存储同一种数据类型的多个元素的容器。 (2)特点：每一个元素都有编号，从0开始，最大编号是长度-1。编号的专业叫法：索引 (3)定义格式 A:数据类型[]
复制链接

扫一扫