Java基础系列二之数组

数组

概念:存储多个元素并且多个元素是同一种类型的容器
数组的定义:

                  1)数据类型[] 数组名;
                  2)数据类型 数组名[];
举例:
                int[] a 定义了一个int类型的数组变量a  /*推荐使用*/

   int a[]               定义了一个int类型变量a数组
 这两种方式的定义虽然写法不一样,读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;

数组的初始化:

                    1)动态初始化:  给数组指定长度,数组中的元素值由系统默认给定
                    2)静态初始化:  给定数组元素的值,数组的长度由系统给定;
动态初始化: 数据类型[] 数组名 = new 数据类型[数组长度] ;

举例:  int[] arr = new int[3] ;
                    int[] arr ;
    System.out.println(arr);

    没有被初始化的数组是不能使用的
Java内存分配空间图解



分析数组初始化语句:
int[] arr = new int[3] ;

左边:            1)int[]: 定义的是一个int类型的数组
                    2)arr: 数组名称 
右边:
                   1)new :创建一个数组对象(它会在堆内存中创建)
                   2)int[]: 当前int类型的数组
                   3) 3: 当前数组的长度是3
如何获取数组中的元素
通过数组名称获取
格式：
                    数组名称[索引值]，索引值从0开始,最大的索引值为数组长度-1(数组的长度为数组名.length)

举例: 
int arr[]=new arr[3];
System.out.println(arr[0]);         //输出第一个数组元素
System.out.println(arr[1]);        //输出第二个数组元素
System.out.println(arr[2]);        //输出第三个数组元素
需求:
   1)创建一个数组,先输出数组名称和它的元素值

  2)给当前数组中的某些元素进行赋值,然后再输出数组名称和元素值
代码:



Java两个数组的内存分配图解



需求:
        1)创建两个数组,分别输出数组名称和数组中的元素
  2)给两个数组中的某些元素进行赋值,再次分别输出数组名称和数组中元素



Java三个数组的内存分配图解



需求:
       1)创建两个数组,分别输出数组名称和元素,给前两个数组进行赋值;
       2)创建第三个数组,将第一个数组的名称赋值给第三个数组,通过第三个数组的名称进行赋值,输出第一个数组的元素

代码:



数组的静态初始化
    指定数组的元素,长度由系统给定
原始格式:

    数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
简写方式:
     数据类型[] 数组名称= {元素1,元素2,元素3..} ; 
举例:
    int[] arr = new int[]{1,2,3} ;
    int[] arr = {1,2,3} ;
                  int[] arr = new int[]{21,432,543,764};
注意！！！
这种方式错误:动静结合。定义数组要么动态初始化,指定长度,要么静态初始化,指定数组元素。
  int[] arr2 = new int[3]{1,2,3} ;

代码:



数组中经常会出现的异常:
   ArrayIndexOutOfBoundsException:数组角标越界异常
   出现的原因:访问了数组中不存在的索引值;
   解决方案:观察数组中到底有索引值到多少;  数组长度-1
   NullPointerException:空指针异常 (在实际开发中该异常是最多的)
  出现的原因:对象为null,而开发者还要去使用对象,就会出现问题

   解决方案:给某个对象进行非空判断。
                OOM异常:OutOfMemory:内存溢出   Android 解决加载大量图片的问题:图片加载器:ImageLoader等等防止程序空                                  指针异常
  对于异常:

    1)将从头到尾遇见的异常建立文档；
                 2)出现该异常的原因;
                 3)如何解决异常;
Test代码:
1)package org.westos.array;
/**
* 数组中的应用:
* 给定一个数组,静态初始化的,遍历这个数组;
* @author Administrator
*
*/
public class ArrayTest {

public static void main(String[] args) {

//定义数组,静态初始化
int[] arr = {11,22,33,44,55} ;

/**
* 获取数组中的元素值,通过数组名称[索引]获取
*/
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]);

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

//遇见这种重复性高的代码,可以采用for循环 :循环的思想
for(int x = 0 ; x < 5 ; x ++) {
System.out.println(arr[x]);
}

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

int[] arr2 = {11,22,33,44,56,78,23,10,20,30} ;
//如果数组中的元素非常多,元素个数非常麻烦
/**
* 针对这种情况,Java提供数组的属性:lenth属性
* 获取数组中的长度
*/
System.out.println(arr.length);
System.out.println(arr2.length);
System.out.println("----------------------");

//将上述代码继续改进,使用数组的长度进行操作
for(int x = 0 ;x < arr.length ; x ++) {
System.out.println(arr[x]);
}

//继续改进:学习方法,所以将遍历的功能写成一个独立的代码块
//调用
printArray(arr2);
System.out.println("------------------------");
printArray(arr) ;

System.out.println("------------------------");
//遍历数组之后:[11, 22, 33, 44, 55]
printArray2(arr);
printArray2(arr2);
}
/**
* 定义方法:两个明确
* 1)返回值类型: 没有具体返回值:void
* 2)参数类型:int类型数组
*
*/
public static void printArray(int[] arr) {
for(int x = 0 ; x < arr.length ; x ++) {
System.out.println(arr[x]);
}
}

//最终改进:
public static void printArray2(int[] arr) {
//左中括号
System.out.print("[");
for(int x = 0 ; x < arr.length ; x ++) {
//判断当前x是否是最后一个索引
if(x==arr.length-1) {//如果是最后一个索引
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
}
2)package
4000
org.westos.array;
/**
* 数组中的最值应用:
* 自定义一个数组,静态初始化,求数组中的最大值或者最小值;
*
* 分析: 最大值:
* 1)定义一个数组,静态初始化
* 2)定义一个参照物,分别和数组中的其他元素进行比较,如果后面的元素都大于参照物,将后面作为参照物作为最大值
* 3)输出
* @author Administrator
*
*/
public class ArrayTest2 {

public static void main(String[] args) {

//定义一个数组
int[] arr = {13,98,24,30,10} ;

//定一个参照物,假设参照物就是最大值
int max = arr[0] ;

//从1开始遍历其他元素
for(int x = 1 ; x < arr.length ; x ++) {
//获取每一个元素
//依次和参照物进行比较,如果后面的元素都大于参照物,将后面作为参照物作为最大值
if( arr[x] > max) {
//将arr[x]赋值给max
max = arr[x] ;
}
}
//输出
System.out.println("最大值是:"+max);
System.out.println("------------------------------");

int max2 = max(arr) ;
System.out.println("最大值是:"+max2);
}
/**
* 定一个方法
* 两个明确:
* 1)明确返回值类型: int类型
* 2)明确参数类型:int[] arr
*/
public static int max(int[] arr) {
//定义参照物
int max = arr[0] ;

//遍历其他元素
for(int x = 1 ; x < arr.length ; x ++) {
//获取到每一个元素,分别和参照物进行比较,如果大了,就作为最大值进行继续比较
if(arr[x] > max) {
max = arr[x] ;
}
}
return max ;
}
}3)package org.westos.array;
/**
* 定义一个数组,元素逆序
*
* 分析:
* 定义一个数组,静态初始化
* 将数组中0索引对应的元素和arr.length-1索引对应的元素进行互换
* 将1索引对应的元素和arr.length-1-1索引对应的元素进行互换
* ....
* 只要保证数组的长度arr.length/2
* @author Administrator
*
*/
public class ArrayTest3 {

public static void main(String[] args) {

//定义一个数组,静态初始化
int[] arr = {12,98,50,76,24,78} ;//78 24 76 50 98 12

System.out.println("遍历前:");
printArray(arr);
System.out.println("------------------");
System.out.println("逆序后:");
// reverse(arr);
revers2(arr);
printArray(arr);

}

/**
* 逆序的方法
* 1)明确:明确返回值类型 void
* 2)明确参数类型:int[] arr
* @param arr
*/
public static void reverse(int[] arr)

//使用中间的方式进行互换
//第一次交换
// int temp = arr[0] ;
// arr[0] = arr[arr.length-1-0] ;
// arr[arr.length-1-0] = temp ;
//
// //第二次互换
// temp = arr[1] ;
// arr[1] = arr[arr.length-1-1] ;
// arr[arr.length-1-1] = temp ;
//
// //第三次
// temp = arr[2] ;
// arr[2] = arr[arr.length-1-2] ;
// arr[arr.length-1-2] = temp ;

//第四次

//....
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 ;
}
}

//方式2;
public static void revers2(int[] arr) {
for(int start = 0,end = arr.length-1 ; start<=end ;start++,end --) {
//temp中间变量
int temp = arr[start] ;
arr[start] = arr[end] ;
arr[end] = 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.println(arr[x] +"]");
}else {
System.out.print(arr[x] +", ");
}
}
}
}
4)

package org.westos.array;

import java.util.Scanner;

/**
* 数组中的元素基本查找法:  ----->数值中的元素的查找,查找的是该元素在数组中的索引
*
* 		有一个字符串数组
* 			String[] str = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;
*
* 	键盘录入一个数据,查找值对应星期几..
*
* @author Administrator
*
*/
public class ArrayTest4 {

public static void main(String[] args) {

//		int a ;//必须初始化,(在使用之前)

//定义一个字符串数组
String[] str = {"星期一","星期二","星期三","星期四","星期五","星期六","星期天"} ;

//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;

//接收数据
System.out.println("请输入一个数据:(0-6):");
int index = sc.nextInt() ;

System.out.println("你要查找的是:"+str[index]);
}
}

5)package org.westos.array;
/**
* 数组中的元素查找法(数组中的基本查找法)
* 定义一个数组,静态初始化,查找某个元素在该数组中第一次出现的索引
*
* 分析:
* 1)给出了数组
* 2)写一个查找数组中的元素的索引的方法
* @author Administrator
*
*/
public class ArrayTest5 {

public static void main(String[] args) {

//定义一个数组:
int[] arr = {200,250,38,101,300} ;
//需求1:查找250这个元素在数组中第一次出现的索引
int index = findIndex(arr, 250) ;
System.out.println("250元素在数组中第一次出现的索引是:"+index);
// //需求2:查找2500这个元素在数组中第一次出现的索引
int index2 = findIndex(arr, 2500) ;
System.out.println("2500元素在数组中第一次出现的索引是:"+index2);
int index3 = getIndex(arr, 38) ;
System.out.println("index3:"+index3);
int index4 = getIndex(arr, 380) ;
System.out.println("index4:"+index4);
}

/**
* 定义一个查找数组中元素的方法
* 两个明确
* 1)返回值类型:int
* 2)参数类型:int [] arr ,两个参数, 第二个参数:int value
*/
public static int findIndex(int[] arr,int value) {
//遍历arr数组元素
for(int x = 0 ; x < arr.length ; x ++) {
//判断:如果查找的元素恰好就是value值,那么直接返回该索引
if(arr[x] == value) {
return x ;
}
}
//不但要考虑找到的情况,还要考虑到找不到的情况
//在Java中,数组查找元素,如果找不到,返回-1 ,(找不到)
return - 1;
}
//方式2,假设法
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 ;
}
}