数组基础知识

1.数组定义

多个相同类型的数据的组合。

数组的作用：实现对这些数据的统一管理，解决数据的批量存储问题。

（将同种类型的数据进行封装，抽象成一个对象，直接用对象实现对这些数据的统一管理，符合面向对象的思想）

核心：数组就是一个对象，数组中的元素是对象的成员变量。

2.数组的使用

1)声明和创建
**元素类型[] 数组名（本质，数组类型的引用变量） = new 元素类型[数组长度];**
数组中元素的类型可以是任意类型（基本类型和引用类型）

2)数组的初始化
动态初始化：数组声明且为数组元素分配空间与赋值的操作可以分开。

基本类型：

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2]  = 8;
引用类型：
MyDate dates[];

dates = new MyDate[3];

dates[0] = new MyDate(22, 7, 1964);

dates[1] = new MyDate(1, 1, 2000);

dates[2] = new MyDate(22, 12, 1964)     ;

静态初始化：在定义数组的同时就为数组元素分配空间，并进行赋值。

基本类型：
两种写法：int[] a= new int[] {3,9,8};
int[] a = {3,9,8}; 数组定义和赋值必须在同一行。
引用类型：
MyDate dates[] = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)}

3.数组和for循环

数组中保存的是同种类型的元素，无论在做什么操作的时候都有可能是一个循环的过程。

利用for循环给数组进行赋值

利用for循环遍历数组

代码分析：

1.数组创建，创建时要关注数组的长度，使用for循环创建和遍历数组要避免数组越界，越界会报异常。

体会for循环和数组下标之间的关系。

for循环为数组赋值和遍历数组分开做。

class ArrayTest1 {

public static void main(String[] args) {
int[] arr = new int[5]; // 有效下标是0~长度-1
for (int i = 0; i < 5; i++) { // 数组和循环是在一起
// 0~4
arr[i] = (i + 1) * 10;
}

// 数组的遍历(迭代)
for (int i = 0; i < 5; i++) {
System.out.println(arr[i]);
}
}
}

2.创建一个奇数数组

/**
创建一个数组，保存10个奇数，遍历数组打印输出
*/
class ArrayTest2 {

public static void main(String[] args) {

int[] oddArr = new int[10];
//1 3 5 7 9
for(int i = 0; i < 10; i++) {
//将奇数保存
oddArr[i] = 2 * i + 1;
}

for(int i = 0; i < 10; i++) {
System.out.print(oddArr[i] + "\t");
}
}
}

class ArrayTest3 {

public static void main(String[] args) {
int[] arr = new int[50]; // 数组对象一旦创建,长度就是固定的,不可改变
System.out.println("数组长度:" + arr.length);
//arr.length = 10; arr.length是一个常量, 固定不变

for (int i = 0; i < arr.length; i++) { // 数组和循环是在一起
// 0~4
arr[i] = (i + 1) * 10;
}

// 数组的遍历(迭代)
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

3.char型数组

/**
1)创建26个元素的字符数组，保存26个小写字母，遍历打印输出
2)创建36个元素的字符数组，前26个保存小写字母，后10个保存10个数字字符
3)创建6个元素的数组，保存你的生日和今天的日期，最后打印输出
4)创建一个数组，保存所有汉字，打印输出
*/
public class CharArrayTest {

public static void main(String[] args) {
/*
1)创建26个元素的字符数组，保存26个小写字母，遍历打印输出
*/
//声明长度为26的字符串数组cArr
char[] cArr = new char[26];
//利用循环给每个元素进行赋值
for(int i = 0; i < cArr.length; i++) {
cArr[i] = (char)('a' + i);
}
//利用循环打印输出数组中的每个元素
for(int i = 0; i < cArr.length; i++) {
System.out.print(cArr[i] + " ");
}

System.out.println("\n" + "----------------------------------------------------");
/*
2)创建36个元素的字符数组，前26个保存小写字母，后10个保存10个数字字符
*/
char[] cArr2 = new char[36];

for(int i = 0; i < cArr2.length; i++) {

if(i < 26) {
cArr2[i] = (char)('a' + i);
}else {
cArr2[i] = (char)('0' + i - 26);
}
}

for(int i = 0; i < cArr2.length; i++) {
System.out.print(cArr2[i] + " ");
}

System.out.println("\n" + "----------------------------------------------------");

/*
3)创建6个元素的数组，保存你的生日和今天的日期，最后打印输出
*/
//声明长度为6的int[] 型数组，并将数组对象的地址写入引用变量iArr中
int[] iArr = new int[6];
//对数组中的每个元素进行赋值
iArr[0] = 1993;
iArr[1] = 11;
iArr[2] = 11;
iArr[3] = 2016;
iArr[4] = 7;
iArr[5] = 27;
//打印输出生日
for(int i = 0; i < 3; i++) {
System.out.print(iArr[i] + ".");
}
System.out.println(" ");
//打印输出今天的日期
for(int i = 3; i < iArr.length; i++) {
System.out.print(iArr[i] + ".");
}

System.out.println("\n" + "----------------------------------------------------");
/*
4)创建一个数组，保存所有汉字，打印输出
汉字的Unicode码值 4e00 ~ 9fa5
unicode码对每一个字符用4位16进制数表示
parseInt(String s, int radix)
*/
String start = "\\u4e00";
String end = "\\u9fa5";
//将unicode码转换成int型判断个数
int s = Integer.parseInt(start.substring(2,start.length()),16);
int e = Integer.parseInt(end.substring(2,end.length()),16);
//定义一个长度为所有汉字总个数的 char[] 数组
char[] cArr3 = new char[e - s];
//存储所有汉字到字符数组中
for(int i = 0; i < cArr3.length; i++) {
cArr3[i] = ((char)(s + i));
}
//遍历数组
for(int i = 0; i < cArr3.length; i++) {
System.out.print(cArr3[i] + " ");
}
}
}

4.main方法中的(String[] args)

有关命令行参数的练习

/*
从命令行接收8个(有效)分数值，如果分数值大于等于90，打印优，
大于60小于等于90，打印及格，小于60打印不及格
使用命令行参数的练习
*/
class Exer2 {

public static void main(String[] args) {

for(int i = 0; i < args.length; i++) {

int score = Integer.parseInt(args[i]);
if (score >= 90) {
System.out.println(args[i] + ":优");

}else if(score >= 60){
System.out.println(args[i] + ":及格");
}else {
System.out.println(args[i] + ":不及格");
}
}
}
}

5.引用类型数组

/*
字符串数组
*/
class Exer1{

public static void main(String[] args) {
//声明数组的简单写法,这种写法声明和初始化必须在同一行
//静态初始化:在定义数组的同时就为数组元素分配空间并赋值。
String[] strArr = {"小明", "小红", "黎明"};
String[] strArr1 = new String[]{"小明", "小红", "黎明"};
//声明数组的简单写法，这种写法声明和初始化可以分开 动态初始化
//初始化(为数组分配空间并赋值)
//动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
String[] strArr2;
strArr2 = new String[]{"小明", "小红", "黎明"};

for(int i = 0; i < strArr.length; i++) {
System.out.print(strArr[i] + " ");
}
System.out.println();
for(int i = 0; i < strArr1.length; i++) {
System.out.print(strArr1[i] + " ");
}
System.out.println();
for(int i = 0; i < strArr2.length; i++) {
System.out.print(strArr1[i] + " ");
}
}
}

/*
创建引用类型的数组(对象)
创建一个MyDate型的数组，保存两个MyDate类的对象，一个是你的生日，一个是今天的日期
*/
class Exer2 {

public static void main(String[] args) {
//声明一个MyDate型数组对象，创建数组，并将数组对象的地址写入md引用变量中
MyDate[] md = new MyDate[2];
md[0] = new MyDate(1993,11,11);
md[1] = new MyDate(2016,7,28);
//若是数组中具有空洞，此时还调用成员方法，就会抛出空指针异常
for(int i = 0; i < md.length; i++) {
System.out.println(md[i].say());
}
}
}
/*
从命令行给MyDate对象赋值
*/
class Exer3 {

public static void main(String[] args) {

MyDate md = new MyDate( Integer.parseInt(args[0]),
Integer.parseInt(args[1]),
Integer.parseInt(args[2]));
System.out.println(md.say());
}
}

MyDate类

/**
创建一个MyDate类
*/
public class MyDate {

private int year;
private int month;
private int day;

public MyDate() {

}
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}

public void setYear(int year) {
this.year = year;
}
public int getYear() {
return year;
}

public void setMonth(int month) {
this.month = month;
}
public int getMonth() {
return month;
}

public void setDay(int day) {
this.day = day;
}
public int getDay() {
return day;
}

public String say() {
return year + "年" + month + "月" + day + "日";
}
}

6.随机数的生成

/**
在指定范围内生成随机数
*/
//5个[10-30)随机整数
public class ArrayTest2 {
public static void main(String[] args) {

for(int i =0; i < 5; i++) {
System.out.println ((int)(Math.random() * 20 + 10));
}
}
}
/*
生成一个随机小数[0~1)
生成一个随机小数[0~101)
生成一个随机整数[0~50)
*/
class RondomDate {

public static void main(String[] args) {
//生成一个随机小数[0~1)
double d = Math.random();
System.out.println(d);
//生成一个随机小数[0~101)
double d2 = Math.random() * 101;
System.out.println(d2);
//生成一个随机整数[0~50)
int i  = (int)(Math.random() * 50);
System.out.println(i);
}
}
// 生成5个[10~30)的随机整数
class RondomDate1 {

public static void main(String[] args) {
//声明一个int型长度为5的数组对象，并将数组对象的地址写入iArr
int[] iArr = new int[5];
//使用循环给数组中的元素进行赋值
for(int i = 0; i < 5; i++) {

iArr[i] = (int)(Math.random() * 20 + 10);
}
//for循环遍历数组iArr
for(int i = 0; i < 5; i++) {
System.out.print(iArr[i] + " ");
}
}
}

7.数组for随机数的综合使用

/*
创建一个int型数组，保存8个元素，这些元素范围[0~20)
对这些数进行求和
对这些数求平均数
对这些数求max min
*/
class Exer4 {

public static void main(String[] args) {

int[] iArr = new int[8];
//利用for循环给数组赋值
for(int i = 0; i < iArr.length; i++) {
iArr[i] = (int)(Math.random() * 20);
}
for(int i = 0; i < iArr.length; i++) {
System.out.print(iArr[i] + " ");
}
System.out.println();
//遍历，在遍历的时候求和 求max，min
/*
先假定下标为0的元素是最大值或者最小值，然后进行比较
*/
int maxDate = iArr[0];
int minDate = iArr[0];
int sumDate = 0;
for(int i = 0; i < iArr.length; i++) {
if(iArr[i] > maxDate) {
maxDate = iArr[i];
}
if(iArr[i] < minDate) {
minDate = iArr[i];
}
sumDate += iArr[i];
}
int avg = sumDate / iArr.length;
System.out.println("这些数的和是:" + sumDate);
System.out.println("这些数中的max:" + maxDate);
System.out.println("这些数中的min:" + minDate);
System.out.println("这些数的平均数是:" + avg);
}
}