Java初级笔记_4_数组

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

Java基础知识

数组

   概述

数组是存储多个变量(元素)的东西(容器)。这多个变量的数据类型要一致

    概念

        数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。数组既可以存储基本数据类型，也可以存储引用 数据类型。

一、一维数组

    定义格式

格式1： 数据类型[] 数组名；推荐使用格式1
格式2： 数据类型   数组名[];

    数组的初始化

概述

Java中的数组必须先初始化,然后才能使用。所谓初始化，就是为数组中的数组元素分配内存空间，并为每个数组 元素赋值。

A: 动态初始化： 只指定长度，由系统给出初始化值

           格式：

    数据类型[] 数组名 = new 数据类型[数组长度];数组长度其实就是数组中元素的个数。

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

       格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

       数据类型[] 数组名 = {元素1,元素2,…};

数组操作的两个常见小问题

越界

ArrayIndexOutOfBoundsException:数组索引越界异常
原因：你访问了不存在的索引。

空指针

NullPointerException:空指针异常
原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

二、二维数组

     概述

    二维数组其实就是每一个元素为一维数组的数组。

 格式1：

    数据类型[][] 变量名 = new 数据类型[m][n];
 m表示这个二维数组有多少个一维数组
 n表示每一个一维数组的元素个数

     数据类型 数组名[][] = new 数据类型[m][n];
     数据类型[] 数组名[] = new 数据类型[m][n];这两种格式不推荐使用

 注意下面定义的区别
int x,y;
int[] x,y[];

         格式2：

      数据类型[][] 变量名 = new 数据类型[m][];
   m表示这个二维数组有多少个一维数组
   这一次没有直接给出一维数组的元素个数，可以动态的给出。

 格式3：

      数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
     简化版:
        数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

     注：这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度

三、数组操作

    遍历

public static void main(String[] args) {
/*
数组遍历：就是依次输出数组中的每一个元素。
*/
// 定义一个int类型的数组 , 并对其进行静态初始化
int[] arr = {1, 3, 5, 7  } ;
// 原始做法
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

System.out.println("----------------------");

// 看到重复性的动作,想到了循环,所以我们可以使用循环将其改进
for(int x = 0 ; x < 4 ; x++){
System.out.println(arr[x]);
}
System.out.println("----------------------");
// 这对数组,java给我们提供一个属性(length) , 来获取数组的长度: 格式: 数组名.length
// 输出数组的长度
System.out.println(arr.length);
System.out.println("----------------------");
// 改进遍历
for(int x = 0 ; x < arr.length ; x++){
System.out.println(arr[x]);
}
System.out.println("----------------------");
// 使用方法改进
// 调用方法
// 直接调用
print2(arr);
}
/*
两个明确:
返回值类型: void
参数列表: int[] arr
*/
public static void print(int[] arr){
for(int x = 0 ; x < arr.length ; x++){
System.out.print(arr[x] + " ,  ");
}
}
// 漂亮的遍历方式
public static void print2(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.print(arr[x] + " , ");
}
}
}

     获取最值

      public static void main(String[] args) {
// 数组获取最值(获取数组中的最大值或者最小值)
// 定义一个int类型的数组
int[] arr = {34,56,780,99,11};
// 定义一个参照物
int max = arr[0] ;
// 遍历数组获取每一个元素和参照物进行比较
// 如果数组的元素大于参照物 , 将数组的元素赋值给参照物
for(int x = 0 ; x < arr.length ; x++){
if(arr[x] > max){
max = arr[x] ;
}
}
// 输出
System.out.println(max);
System.out.println("---------------------------");
// 调用方法 
// 赋值调用
int result = getMax(arr);
System.out.println(result);
}
/*
两个明确:
返回值类型: int
参数列表: int[] arr
*/
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 void main(String[] args){
// 数组元素反转(就是把元素对调)
// 定义一个数组
int[] arr = {23, 56, 78, 12 , 45 , 99} ; 
System.out.print("反转前: ");
print(arr);
// {99 , 45 , 12 , 78, 56 , 23}
for(int x = 0 , y = arr.length - 1 ; x < y ; x++ , y--){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
System.out.print("反转后: ");
print(arr);
}
// 遍历
public static void print(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.print(arr[x] + " , ");
}
}
}

     查表法

      public static void main(String[] args) {
// 数组查表法(根据键盘录入索引,查找对应星期)
String[] arr = {"" , "星期一" , "星期二" , "星期三" , "星期四" , "星期五" , "星期六" , "星期日"} ;
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请您输入一个索引: ");
// 获取键盘录入数据
int num = sc.nextInt() ;
// 判断
if( num < 1 || num >= 8){
System.out.println("您输入的数据有误!!!");
}else {
// 获取元素值
System.out.println(arr[num]);
}
}

     基本查找

      public static void main(String[] args) {
// 数组元素查找(查找指定元素第一次在数组中出现的索引)
// 定义一个int类型的数组
int[] arr = {34 , 12 , 99 , 45 , 67 , 45} ;
// 赋值调用
int index = getIndex2(arr , 45);
// 输出
System.out.println(index);
}
/*
两个明确:
返回值类型: int
参数列表:   int[] arr , int value
思路:
遍历数组,获取数组中的每一个元素, 和指定元素进行比较,如果相等 , 就返回当前的索引值
*/
public static int getIndex(int[] arr , int value){
for(int x = 0 ; x < arr.length ; x++){
if(arr[x] == value){
return x ;
}
}
return -1 ;
}
// 第二种方式
public static int getIndex2(int[] arr , int value){
// 定义一个变量,用来存储对应的索引
int index = -1 ;
// 遍历数组
for(int x = 0 ; x < arr.length ; x++){
if(arr[x] == value){
index = x ;
break ;
}
}
// 返回
return index ;
}

     杨辉三角

      public static void main(String[] args) {
// 定义二维数组
/*
int[][] arr = {{1}, {1, 1} , {1, 2, 1} , {1, 3, 3, 1} , {1, 4, 6, 4, 1} , {1, 5, 10, 10 , 5, 1}} ;
// 遍历
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();
}
*/
// 创建键盘录入对象
Scanner sc = new Scanner(System.in);
System.out.println("请您输入一个数: "); 
// 获取键盘录入数据
int n = sc.nextInt();
System.out.println("----------------------");
// 构建一个每一个一维数组的长度是固定的二维数组
int[][] arr = new int[n][n] ;
// 每一行的第一列和最后一列的值都是1
for(int x = 0 ; x < arr.length ; x++){
arr[x][0] = 1 ;
arr[x][x] = 1 ;
}
// 从第三行开始,除去第一列与最后一列,其余数的值 = 上一行的前一列的值 + 上一行的当列的值
for(int x = 2 ; x < arr.length ; x++){
for(int y = 1 ; y < arr[x].length ; 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();
}
}

四、Java中的内存分配以及栈和堆的区别

    A:栈:存放的是局部变量
          局部变量：在方法定义中或者方法声明上的变量都是局部变量。
     B:堆: 存放的是所有new出来的东西
          特点：
a:每一个new出来的东西都会为其分配一个地制值。
b:每一个变量都有一个默认的值
     byte，short，int，long  -- 0
     float，double     -- 0.0
     char     -- '\u0000'
     boolean     -- false
     引用数据类型     -- null
c:使用完毕就变成了垃圾，等待垃圾回收器对其回收
     C:方法区:面向对象部分再说
     D:本地方法区:(和系统相关)
     E:寄存器:(cpu使用)

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