数组玩法（二）

本博客主要是以引用型数组为例子，介绍各种玩法。

各种玩法本质和基本数据类型一致，不做详细介绍了。

核心：引用型数组，操作的是引用，而不是对象本身，各种操作都是地址的事。

先来一个Student类

/**
写一个学生类，属性：int id, String name, int grade, double score
将该类属性进行封装，为外界提供公共的get/set方法
无参构造器，全参构造器
声明一个say()方法，返回对象的所有属性
*/
public class Student {
//属性
private int id;
private String name;
private int grade;
private double score;
//无参构造器
public Student() {

}
//全参构造器
public Student(int id, String name, int grade, double score) {
this.id = id;
this.name = name;
this.grade = grade;
this.score = score;
}
//id的set/get方法
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
//setName的set/get方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//setGrade的set/get方法
public void setGrade(int grade) {
this.grade = grade;
}
public int getGrade() {
return grade;
}
//setScore的set/get方法
public void setScore(double score) {
this.score = score;
}
public double getScore() {
return score;
}
//say()方法，返回对象的所有属性
public String say() {
return "学号:" + id + "\t姓名:" + name + "\t年级:" + grade + "\t分数:" + score;
}
}

开始玩：

/**
写一个测试类，测试引用类型数组的各种玩法
1) 创建一个学生对象数组有20个元素, 使用循环创建对象, 学生的id是从1-20,姓名,
年级和分数都是随机生成
遍历这个数组,打印每个对象的信息
2) 遍历数组时, 只打印3年级的学生的信息
3) 求学生的平均分数..
4) 找出学生中的最高分和最低分
//程序的编写要提高程序的灵活性
*/
public class StudentTest {

public static void main(String[] args) {
//设置姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};     //姓
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};    //名
//创建一个元素类型是Student的，数组名是stuArr，长度为20的数组
Student[] stuArr = new Student[20];
/*
设置循环给stuArr数组赋值
其中id 1~20
name 随机生成(姓名库)
grade随机生成[1~6]
score随机生成[0~100]
*/
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
//随机生成姓 名的索引
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
//合成随机姓名
String name = name1[randIndex1] + name2[randIndex2];
//生成随机年级
int grade = (int)(Math.random() * 6 + 1);
//生成随机分数
double score = (int)(Math.random() * 101);

//int id, String name, int grade, double score
//根据生成的随机的数据给Student型数组赋值
stuArr[i] = new Student(id, name, grade, score);
}
/*
//经典for循环
for (int i = 0; i < stuArr.length; i++) {
System.out.println(stuArr[i].say());
}
*/

/*
增强for循环，只能遍历数组，
当在遍历的时候需要做一些其他的事时只能使用经典for循环
语法： 元素类型 变量名 : 数组名 {sys(变量名)}
*/
for(Student stu : stuArr) {
System.out.println(stu.say());
}

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

// 2) 遍历数组时, 只打印3年级的学生的信息
for (int i = 0; i < stuArr.length; i++) {
//根据条件打印学生的信息
if (stuArr[i].getGrade() == 3) {
System.out.println(stuArr[i].say());
}
}

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

// 3) 求学生的平均分数
//定义一个保存成绩的变量sum
double sum = 0;
//利用for循环遍历，并求和
for (int i = 0; i < stuArr.length; i++) {
//求和
sum += stuArr[i].getScore();
}
//计算平均分
//能用变量的地方不使用字面值，提高程序的灵活性
double avg = sum / stuArr.length;
//打印平均分
System.out.println("平均分:" + avg);

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

// 4)通过值找出学生中的最高分和最低分(只找出最高分和最低分就行)
//将数组中的第一个元素的分数赋值给max
double max = stuArr[0].getScore();
//将数组中的第一个元素的分数赋值给min
double min = max;
//遍历数组
for (int i = 0; i < stuArr.length; i++) {
//如果第i个元素的分数大于max，修改max的值
if (stuArr[i].getScore() > max) {
max = stuArr[i].getScore();
}
//如果第i个元素的分数小于min，修改min的值
if (stuArr[i].getScore() < min) {
min = stuArr[i].getScore();
}
}
//打印
System.out.println("最高分:" + max + ",最低分:" + min);

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

//找出最低分的学生(要可以找到这个学生对象，而不仅仅找到最低分)
//时刻牢记，操作对象实际是在操作对象的引用
/*
因为数组元素的类型是Student型的，实际上，每个数组元素相当于
一个Student型的引用变量，它们其中保存了它们所指向的对象的地址
*/
//创建一个保存第一个数组元素的Student型的引用变量
Student minScoreStudent = stuArr[0];
//循环遍历
for(int i = 0; i < stuArr.length; i++) {
//将第i数组元素所指向的对象的分数与minScoreStudent所指向的对象的分数进行比较，
//若小于，修改minScoreStudent
if(stuArr[i].getScore() < minScoreStudent.getScore()) {
minScoreStudent = stuArr[i];
}
}
System.out.println("最低分的学生是:" + minScoreStudent.say());

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

//找出最高分的学生(要可以找到这个学生对象，而不仅仅找到最高分)
//最高分和最低分原理一致
Student maxScoreStudent = stuArr[0];
//for循环
for(int i = 0; i < stuArr.length; i++) {
//判断
if(stuArr[i].getScore() > maxScoreStudent.getScore()) {
//修改
maxScoreStudent = stuArr[i];
}
}
System.out.println("最高分的学生是:" + maxScoreStudent.say());
}
}
/**
利用上边随机创建的Student数组，进行一些数组的常用练习
通过索引找,最高分的学生
*/
class StudentTest2 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//循环遍历给数组进行赋值
for (int i = 0; i < stuArr.length; i++) {

int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
//通过索引找,最高分的学生
int stuMaxIndex = 0;
//for循环遍历
for(int i = 0 ; i < stuArr.length; i++) {

if(stuArr[i].getScore() > stuArr[stuMaxIndex].getScore()) {
stuMaxIndex = i;
}
}
System.out.println("最高分的学生是:" + stuArr[stuMaxIndex].say() + "下标为" + stuMaxIndex);
}
}
/**
找出三年级的最高分和最低分，求平均分
不知道第一个三年级的学生的分数是多少或者值是多少
这种情况我们一开始并不知道max/min应该赋什么值，或者用什么索引
只能给max/min赋极值来解决问题
max问题 先给max赋一个最小的值(所有情况都比它大)
min问题 先给min赋一个最大的值(所有情况都比它小)
*/
class StudentTest3 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[5];
//for循环遍历给数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
//找出三年级的最高分和最低分，求平均分
double maxScore = -1;
double minScore = 101;
double sumScore = 0;
int count = 0;
for(int i = 0; i < stuArr.length; i++) {
//首先只有是三年级的学生才符合我们的要求
if(stuArr[i].getGrade() == 3) {
//判断最大值
if(stuArr[i].getScore() > maxScore){
maxScore = stuArr[i].getScore();
}
//判断最小值
if(stuArr[i].getScore() < minScore){
minScore = stuArr[i].getScore();
}
//对分数进行求和
sumScore += stuArr[i].getScore();
//计数
count ++;
}
}
//输出的时候要考虑一个三年级的学生也没有怎么办
if(count == 0) {
System.out.println("没有三年级的学生");
} else{
double avg = sumScore / count;
System.out.println("三年级中的最高分是:" + maxScore);
System.out.println("三年级中的最低分是:" + minScore);
System.out.println("三年级中的平均分是:" + avg);
}
}
}
/**
同一种情况，需要找出最高分，最低分的学生的详细信息
求平均分
*/
class StudentTest4 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[50];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
//找出三年级的最高分和最低分的学生，求平均分
//这是找对象，对于引用初始值可以赋null。
Student maxScoreOf3 = null;
Student minScoreOf3 = null;
double sumScore = 0;
int count = 0;
for(int i = 0; i < stuArr.length; i++) {
if(stuArr[i].getGrade() == 3) {
//获取最高分的学生
if(maxScoreOf3 == null) {
maxScoreOf3 = stuArr[i];
} else if(stuArr[i].getScore() > maxScoreOf3.getScore()){
maxScoreOf3 = stuArr[i];
}

//获取最低分的学生
if(minScoreOf3 == null) {
minScoreOf3 = stuArr[i];
} else if(stuArr[i].getScore() < minScoreOf3.getScore()){
minScoreOf3 = stuArr[i];
}
count++;
sumScore += stuArr[i].getScore();
}
}
if(count == 0) {
System.out.println("没有三年级的学生");
} else{
double avg = sumScore / count;
System.out.println("三年级中的最高分是:" + maxScoreOf3.say());
System.out.println("三年级中的最低分是:" + minScoreOf3.say());
System.out.println("三年级中的平均分是:" + avg);
}
}
}
/**
将学生数组进行复制
*/
class StudentTest5 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("----------------数组的复制------------------");
//数组的复制
/*
对于引用类型来说，只是将数组元素(引用类型)中保存的地址进行复制，对象还是那些
*/
Student[] newArr =  new Student[stuArr.length];

for(int i = 0; i < newArr.length; i++) {
//每个数组元素保存的对象地址，copy一份写入新的数组元素中
newArr[i] = stuArr[i];
}
//遍历
for (Student stu : newArr) {
System.out.println(stu.say());
}
}
}
/**
获取子数组(子数组的元素个数是原数组的一半)
*/
class StudentTest6 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------获取子数组(子数组的元素个数是原数组的一半)--------------------");

Student[] stuArrChild =  new Student[stuArr.length / 2];
//遍历的时候以容量小的数组长度为准
for(int i = 0; i < stuArrChild.length; i++) {

stuArrChild[i] = stuArr[i];
}
//遍历
for (Student stu : stuArrChild) {
System.out.println(stu.say());
}
}
}
/**
给学生数组扩容
1.创建比原数组长度长的数组
2.复制原数组信息到新数组
3.修改指向，将原来数组名指向新的数组
*/
class StudentTest7 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------给学生数组扩容--------------------");

Student[] stuArrBigger =  new Student[stuArr.length * 2];

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

stuArrBigger[i] = stuArr[i];
}
//修改指向
stuArr = stuArrBigger;
//遍历
for (Student stu : stuArr) {
if(stu != null) {
System.out.println(stu.say());  //扩容以后有null所以不能直接调用对象的方法
} else {
System.out.println(stu);
}
}
}
}
/*
子数组的练习
*/
class StudentTest8 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------获取原来的1/3子数组--------------------");

Student[] stuArrChild =  new Student[stuArr.length / 3];

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

stuArrChild[i] = stuArr[i];
}
//遍历
for (Student stu : stuArrChild) {
System.out.println(stu.say());
}
}
}
/*
数组扩容的练习
*/
class StudentTest9 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[20];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------给学生数组扩容1.5倍--------------------");

Student[] stuArrBigger =  new Student[(int)(stuArr.length * 1.5)];

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

stuArrBigger[i] = stuArr[i];
}
//修改指向
stuArr = stuArrBigger;
//遍历
for (Student stu : stuArr) {
if(stu != null) {
System.out.println(stu.say());  //扩容以后有null所以不能直接调用对象的方法
} else {
System.out.println(stu);
}
}
}
}
/**
从数组中获取值的练习
把三年级的学生提取出来
1.先创建一个跟原数组一样大小的数组
2.将原数组中符合条件的复制到新数组中并计数(注意，在复制过程中原数组和新数组的索引不同)
3.将新数组利用计数的结果复制生成最终数组
*/
class StudentTest10 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[50];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}

System.out.println("--------------把三年级的学生提取出来--------------------");

Student[] newStuArr =  new Student[stuArr.length];
int count = 0;
//先复制生成新数组
for(int i = 0; i < newStuArr.length; i++) {
if(stuArr[i].getGrade() == 3) {
newStuArr[count] = stuArr[i];
count++;
}
}
//复制生成最终数组
Student[] stuArrFinal = new Student[count];
for(int i = 0; i < stuArrFinal.length; i++) {
stuArrFinal[i] = newStuArr[i];
}
//遍历
for (Student stu : stuArrFinal) {
System.out.println(stu.say());
}
}
}
/**
数组反转
*/
class StudentTest11 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[10];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------数组反转--------------------");

for (int i = 0; i < (stuArr.length / 2); i++) {
Student stu = stuArr[i];
stuArr[i] = stuArr[stuArr.length - 1 - i];
stuArr[stuArr.length - 1 - i] = stu;
}
//遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
}
}
/**
数组排序
*/
class StudentTest12 {
public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[10];
//利用for循环对数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------学生按照成绩从低到高排序--------------------");

//冒泡排序，外层控制趟数 length - 1
/*
若共有n个元素需要排序
趟数  需要比较的元素个数
1      n-1
2      n-2
3      n-3
n-1    n-(n-1)=1
所以共n-1趟
*/
for (int i = 0; i < stuArr.length - 1; i++) {
//每次比较的元素个数
for(int j = 0; j < stuArr.length - 1 - i; j++) {

if(stuArr[j].getScore() > stuArr[j + 1].getScore()) {
//交换
Student stu = stuArr[j];
stuArr[j] = stuArr[j + 1];
stuArr[j + 1] = stu;
}
}
}
//增强for循环，遍历数组，
for (Student stu : stuArr) {
System.out.println(stu.say());
}
}
}
/*
学生按照成绩从高到低排序
*/
class StudentTest13 {

public static void main(String[] args) {
//姓名库
String[] name1 = {"张", "李", "赵", "徐", "贾"};
String[] name2 = {"杰", "伟", "刚", "丽", "琳", "云"};
//创建数组
Student[] stuArr = new Student[10];
//for循环遍历给数组进行赋值
for (int i = 0; i < stuArr.length; i++) {
int id = i + 1;
int randIndex1 = (int)(Math.random() * name1.length);
int randIndex2 = (int)(Math.random() * name2.length);
String name = name1[randIndex1] + name2[randIndex2];
int grade = (int)(Math.random() * 6 + 1);
double score = (int)(Math.random() * 101);

stuArr[i] = new Student(id, name, grade, score);
}
// 遍历
for (Student stu : stuArr) {
System.out.println(stu.say());
}
System.out.println("--------------学生按照成绩从高到低排序--------------------");
//外层循环控制趟数
for (int i = 0; i < stuArr.length - 1; i++) {
//内层循环控制比较的元素个数
for(int j = 0; j < stuArr.length - 1 - i; j++) {
//交换
if(stuArr[j].getScore() < stuArr[j + 1].getScore()) {
Student stu = stuArr[j];
stuArr[j] = stuArr[j + 1];
stuArr[j + 1] = stu;
}
}
}
//增强for循环，遍历数组，
for (Student stu : stuArr) {
System.out.println(stu.say());
}
}
}

简单粗暴，直接贴一个大型代码块，满足所有需求。

详情参考数组玩法（一）

留言一起学习，一起进步。