一维数组链接：https://blog.csdn.net/weixin_56219549/article/details/120408159.
一、二维数组
- 二维数组，其实Java中只有一维数组，没有二维数组
- 二维数组就是（元素是一维整型数组的int[]的）一维数组
- 三维数组就是（元素是二维数组的）一维数组
示例：存储3个 班的学生成绩，每个班4个人
/**
*
* 解决方案1：定义一个数组，12个元素，存储12个学生成绩
* 不可以：存储1个班12个学生的成绩
*
* 解决方案2：定义3个数组，每个数组4个元素
* 不可以：太繁琐了。
*
* 解决方案3：定义1个二维数组，存储3个班，每个班四名学生的成绩
* OK
*
*/
public class doubleArray {
public static void main(String[] args) {
//定义一个二维数组
int [][] scores = new int[3][4];
//存储学生成绩
scores[0][0]=100;
scores[0][1]=90;
scores[0][2]=98;
scores[0][3]=76;
scores[1][0]=98;
scores[1][1]=89;
scores[1][2]=100;
//scores[1][3]=100;
scores[2][0]=98;
scores[2][1]=78;
scores[2][2]=67;
//还有以下2中方法初始化二维数组
//int [][] scores = new int[][]{{100,90,98,76},{98,89,100},{98,78}};
//int [][] scores = {{100,90,98,76},{98,89,100},{98,78}};
//了解二维数组的特点（length）
System.out.println(scores[0][2]);//第一个班第3个学生的成绩
System.out.println(scores.length);
System.out.println(scores[0].length);
System.out.println(scores[1].length);
System.out.println(scores[1][1]);
//输出学生成绩
for(int i=0;i<scores.length;i++){
System.out.println("第"+(i+1)+"个班的学生成绩");
for(int j=0;j<scores[i].length;j++){
System.out.print(scores[i][j]+"\t");
}
System.out.println();
}
}
}
总结
- 1：二维数组不要求每个元素所指向的一维数组长度相同。
- 2：二维数组的静态初始化=声明+分配空间+赋值，和一维数组类似。
二、使用数组存储引用类型数据及排序
示例代码
import java.util.Arrays;
class Student implements Comparable{
private String name;
private int age;
private double score;
@Override
public int compareTo(Object obj) {
//强制转换
Student other = (Student)obj;
//进行比较并返回结果
//return this.age - other.age;
//return (int)(this.score - other.score);//56.6 56.3 存在精度问题用以下方法
// if(this.score-other.score>0){
// return 1;
// }else if(this.score - other.score<0){
// return -1;
// }else{
// return 0;
// }
//return this.name-other.name;报错用以下方法
return this.name.compareTo(other.name);
}
public Student() {
super();
}
public Student(String name, int age, double score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score+ "]";
}
}
public class Test1 {
public static void main(String[] args) {
// //声明并分配空间
// Student [] stuarr = new Student[6];
// //存储6个学生
// stuarr[0] = new Student("aaa", 23, 90);
// stuarr[1] = new Student("bbb", 22, 91);
// stuarr[2] = new Student("ccc", 23, 92);
// stuarr[3] = new Student("abc", 24, 90);
// stuarr[4] = new Student("cba", 23, 94);
// stuarr[5] = new Student("bca", 23, 99);
Student[] stuarr = new Student[]{
new Student("aaa", 23, 90),
new Student("bbb", 22, 91),
new Student("ccc", 23, 92),
new Student("abc", 24, 90),
new Student("cba", 23, 94),
new Student("bca", 23, 99)
};
//输出6个学生不鞥
for(int i=0;i<stuarr.length;i++){
System.out.println(stuarr[i]);
}
for(Student stu :stuarr){
System.out.print(stu.getName() + " ");
}
System.out.println();
//输出第6个学生
System.out.println(stuarr[5].getName()+" "+stuarr[5].getAge()+" "+stuarr[5].getScore());
Arrays.sort(stuarr);
for(int i=0;i<stuarr.length;i++){
System.out.println(stuarr[i]);
}
}
}
Comparable（内部比较器）作用
//不implements接口和重写compareTo对象进行排序会报错
Arrays.sort(stuarr);
Comparable源码
public interface Comparable<T> {
public int compareTo(T o);
}
compareTo源码
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
引用数据实现Comparator接口{外部的比较规则}
工具类
import java.util.Comparator;
public class ArrayUtil {
public static void sort(Object [] stuarr,Comparator<Object> comp){
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
Object temp;
for(int i=0;i<stuarr.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<stuarr.length-1-i;j++){
//如果前一个大于后一个
if(comp.compare(stuarr[j], stuarr[j+1])>0){
//交换
temp = stuarr[j];
stuarr[j]=stuarr[j+1];
stuarr[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
}
public static void sort(Object [] stuarr){
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
Object temp;
for(int i=0;i<stuarr.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<stuarr.length-1-i;j++){
//如果前一个大于后一个
@SuppressWarnings("unchecked")
Comparable<Object> c1 = (Comparable<Object>)stuarr[j];
@SuppressWarnings("unchecked")
// 简介：java.lang.SuppressWarnings是J2SE5.0中标准的Annotation之一。可以标注在类、字段、方法、参数、构造方法，以及局部变量上。
// 作用：告诉编译器忽略指定的警告，不用在编译完成后出现警告信息。
Comparable<Object> c2 = (Comparable<Object>)stuarr[j+1];
if(c1.compareTo((Object) c2)>0){
//交换
temp = stuarr[j];
stuarr[j]=stuarr[j+1];
stuarr[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
}
//int [] scores = {89,78,98,67,75,45,89,99,65,31};
//ArrayUtil.sort(scores);
public static void sort(int [] scores){
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
int temp;
for(int i=0;i<scores.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<scores.length-1-i;j++){
//如果前一个大于后一个
if(scores[j]>scores[j+1]){
//交换
temp = scores[j];
scores[j]=scores[j+1];
scores[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
}
public static void sort(double [] scores){
//大循环，一共n个元素，达到最终有序，至多n-1趟比较
double temp;
for(int i=0;i<scores.length-1 ;i++){
//定义一个符号量
boolean flag = true;//没有交换，有序
//小循环
for(int j=0;j<scores.length-1-i;j++){
//如果前一个大于后一个
if(scores[j]>scores[j+1]){
//交换
temp = scores[j];
scores[j]=scores[j+1];
scores[j+1]=temp;
//修改符号量
flag = false;//交换过，无序
}
}
//判断经过此趟循环后是否已经有序
if(flag){
break;//退出外层循环，省略后续趟循环
}
}
}
}
排序
import java.util.Arrays;
class Student implements Comparable<Student>{
private String name;
private Integer age;
private Integer score;
public Student(String name, Integer age, Integer score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
}
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
return 0;
}
}
public class Testsort {
public static void main(String[] args) {
//定义数组
Student[] stuarr = new Student[]{
new Student("aaa", 23, 90),
new Student("bbb", 22, 91),
new Student("ccc", 23, 92),
new Student("abc", 24, 90),
new Student("cba", 23, 94),
new Student("bca", 23, 99)
};
//排序前输出
System.out.println(Arrays.toString(stuarr));
//排序
ArrayUtil.sort(stuarr);
//排序后输出
System.out.println(Arrays.toString(stuarr));
}
}
Comparator源码
equals判断是否是同一个对象
compare比较大小
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
5830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
