数组的使用，对象数组的使用

数组是什么？

顾名思义，数组，就是无序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。

java初始时，

一个变量，只能保存一个值。基本数据类型，保存的是值本身；引用数据类型保存的是内存地址。

方法里的return只能返回一个值。如果参数个数过多，会不方便书写，更容易出错，所以我们有了数组。

那我们如何定义数组？

方式1：

数组类型[] 数组名 = new 数组类型[数组空间个数] (推荐使用)

举个栗子：

public class Test{

public static void main(String[] args) {
int[]  number= new int[5];//因为有new关键字，会开辟新的内存空间并把内存地址返回
System.out.println(number);

}

方式2：

数组类型 数组名[] = new 数组类型[数组空间个数]

方式3：

数组类型[] 数组名 = {值1,值2,值3...}(推荐使用)

方式4：

数组类型[] 数组名 = new 数组类型[数组长度]{值1,值2,值3,....}

我还是比较喜欢使用第三种方式，简单粗暴。

举个栗子：

int[] number = {1,2,0,-5,9};//定义了一组int类型的数组

比如我需要寻找数组中的最大值：

public class Test {
public static void main(String[] args) {
//定义一个数组
int[] is = {1,2,0,-5,9};
//加入第一个是最大值,拿后面的元素和第一个比较，如果后面的元素比第一个大，把最大的存储起来即可
int max = is[0];
for (int i = 1; i < is.length; i++) {//通过for循环遍历，进行比较
if(is[i] > max) {
max = is[i];
}
}
System.out.println(max);
}
}

需要求和

public class Test {
public static void main(String[] args) {
int[] is = {2,3,-50,60,17};
int sum = 0;

for (int i = 0; i < is.length; i++) {
sum = sum + is[i];
}
System.out.println(sum);
}
}

接下来我们看对象数组：

以我的理解，就是将对象放入数组里（也就是说，数组内每个元素都是一个对象）

对象数组就是数组里的每个元素都是类的对象，赋值时先定义对象，然后将对象直接赋给数组就行了<百度百科>

对于java来说，万事万物皆对象。

java中先有类在有对象
类 = 属性 + 方法,不能出现任何语句,语句必须写在方法中
属性: 访问修饰符 属性类型 属性名 = 属性值;
方法: 访问修饰符 返回值类型 方法名(参数){语句(return)}
类无法直接使用,需要生成类对应的对象
生成对象的格式 类名 对象名    = new 类名();
对象名.属性
对象名.方法(实参);

举个栗子:

public class Person {
//属性
String name;
int age;
//方法
public void eat(String name){
System.out.println("人吃的:" + name);
}
}


public class TestPerson {//含有main方法的类称为测试类或者主类
//main方法是程序执行的入口,一个程序只能由一个入口
public static void main(String[] args) {
//生成对象
Person person = new Person();
//调用属性
person.name = "王二";
person.age = 21;
System.out.println(person.name);
System.out.println(person.age);
person.eat("米饭");
}
}

(详细参https://www.cnblogs.com/jsjlxgf/p/6143544.html)

对象数组的形式，

数组类型[] 数组名 = {"对象1","对象2","对象3",......"对象n",};

举个栗子：

String[] str = {"北京","西安","张三","李四"...}

*********************************************************************

数组也有分类，分为一般数组和二维数组

一位数组就是常见的：

int[] a = {1,2,3,5,8,7,-4,5}

或者

String str = {"张三","李四","王二","小黄","二狗蛋"}

一维数组比较简单，不做详细介绍，我们需要注意的数二维数组：

举个栗子：

我们常去的超市，都有一个存放物品的储存柜。

可以看出这是一个三维立体的柜子，一维数组不能满足我们的要求

所以就需要二维数组

int[] h = {1,2,3,4}

int[] g = {1,2,3}

我需要拿出第一行第三列的东西（顺序都是按照从左往右,注意：因为java代码是从0开始的，

第一行第一列的柜子坐标值就是0,0）

int[0] [2] = 03//我们拿到03号柜子的东西

我们如何定义二维数组呢？

方式1：

数组类型[] [] 数组名 = new 数组类型[行数] [列数];

方式2：

数组类型[] [] 数组名 = {{值1,值2,值3....},{值1,值2,值3....},{值1,值2,值3....},{值1,值2,值3....}};

举个栗子：

public class Test{

public static void main (String[] args){

int[][] i = new int [4][5];//如果没有给i赋值，使用的就是默认值0

i [0][0] = 7;

i[1][2] = 15;

int[][] i2= {{1,2,4},2,20,30,40,50},{100,-5,22,70,3}};//i2里已经有对应的值

System.out.println(is2[2][1]);

}

}

使用双重for循环遍历二维数组：

public class Test2{

public static void main(String[] args){

int[][] is2 = {{1,2,4,23,789,23},{2,20,30,40,50},{100,-5,22,70,3}};

//这是一个二维数组，在没有学for循环时候，我们方法：

for(int i = 0;i < is2[0].length;i++) {
// System.out.println(is2[0][i]);
// }


// for (int i = 0; i < is2[1].length; i++) {
// System.out.println(is2[1][i]);
// }
//


// for(int i = 0; i < is2[2].length;i++){
// System.out.println(is2[2][i]);
// }

//使用for循环遍历

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

}

经典面试题：九九乘法口诀：

public class Test000 {
public static void main(String[] args) {
for(int j = 1;j <= 9;j++) {
for(int i = 1;i <= j;i++) {
System.out.print(i + "*" + j + "=" + (i * j) + "\t");
}
System.out.println("");
}
}
}

排序算法1冒泡排序
public class Test5 {
public static void main(String[] args) {
int[] is = {123,3,-5,18,-100,-1000,77,12341234,21,102893,23};
//对该数组从小到大排序
//1.冒泡排序：思路，从第一个元素开始，两两比较，如果后面的比前面的小，然后交换位置，每比较一轮就能得出其最大值

//第一轮比较
// if(is[0] > is[1]) {
// int temp = is[0];
// is[0] = is[1];
// is[1] = temp;
// }
// if(is[1] > is[2]) {
// int temp = is[1];
// is[1] = is[2];
// is[2] = temp;
// }
// if(is[2] > is[3]) {
// int temp = is[2];
// is[2] = is[3];
// is[3] = temp;
// }
// if(is[3] > is[4]) {
// int temp = is[3];
// is[3] = is[4];
// is[4] = temp;
// }
// for(int i = 0;i < 4;i++) {
// if(is[i] > is[i+1]) {
// int temp = is[i];
// is[i] = is[i + 1];
// is[i + 1] = temp;
// }
// }
//第二轮比较
//
// for(int i = 0;i < 3;i++) {
// if(is[i] > is[i+1]) {
// int temp = is[i];
// is[i] = is[i + 1];
// is[i + 1] = temp;
// }
// }
//
//第三轮比较
//
// for(int i = 0;i < 2;i++) {
// if(is[i] > is[i+1]) {
// int temp = is[i];
// is[i] = is[i + 1];
// is[i + 1] = temp;
// }
// }

//第四轮比较
// for(int i = 0;i < 1;i++) {
// if(is[i] > is[i+1]) {
// int temp = is[i];
// is[i] = is[i + 1];
// is[i + 1] = temp;
// }
// }

for(int j = is.length - 1; j > 0;j--) {
for(int i = 0;i < j;i++) {
if(is[i] > is[i+1]) {
int temp = is[i];
is[i] = is[i + 1];
is[i + 1] = temp;
}
}
}


for (int i = 0; i < is.length; i++) {
System.out.println(is[i]);
}
}
}