目录
1 数组的基本定义
2 基本数据类型+引用数据类型（类，接口、数组）代码演示：
2.1 基础代码
public class TestArry {
public static void main(String[] args){
int [] scores = new int[4];
scores[0] = 89;
//scores[1] = 89;
//scores[2] = 89;
scores[3] = 90;
for (int i = 0;i<scores.length;i++){
System.out.println(scores[i]);
}
//对于float double:
float[] f = new float[3];
f[0] = 1.2f;
for (int i = 0;i<f.length;i++)
System.out.println(f[i]);
//char:
char[] c = new char[4];
c[0] = 'j';
for (int i = 0;i<c.length;i++){
System.out.println(c[i]);
}
//对于boolean：
boolean [] b = new boolean[4];
for (int i = 0;i<b.length;i++){
System.out.println(b[i]);
}
//对于引用数据类型，默认初始数据类型为null。以string为例
String[] s = new String[4];
s[0] = "jj";
for (int i = 0;i<s.length;i++){
System.out.println(s[i]);
}
Person[] pers = new Person[];
for (int i = 0;i<pers.length;i++){
System.out.println(pers[i]);
}
}
class Person{ }
}
2.2 运行结果
2.3 表明默认值为
- int 0；
- float double 0.0；
- char 空格；
- boolean false；
- string null；（引用数据类型如数组，默认值都为null）
2.4 基本代码说明
（1）创建基本数据类型数组
（2）创建元素为引用类型(对象)的数组
3 一维数组的内存结构
3.1 一维数组内存基本结构
3.2 内存的使用方式
3.3 练习
（1）学习从主函数遍历外面建立的数组Primitive
package com.atgui.exer;
public class TestPritimive {
public static void main(String[] args){
//创建Primitive的对象d
Primitive d = new Primitive();
//遍历d的数组元素
for(int i =0;i<d.t.length;i++){
System.out.println(d.t[i]);
}
//给d的数组元素重新赋值
d.t[0] = true;
d.t[1] = true;
d.t[2] = true;
for(int i = 0;i<d.t.length;i++){
System.out.println(d.t[i]);
}
}
}
class Primitive{
boolean[] t = new boolean[3];
}
- 感悟：存在于外面的这个类Primitive与Scanner这样的包类似，通过new进行建立与调用；.一般表示功能调用or继 承！创建对象一般而言就是创建一个变量名，可以调用这个类或者接口的功能（核心就是面向对象编程）。
- 包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
（2）读入学生成绩，赋值给数组，打印出最高分并评级
package com.atgui.exer;
/*
* 从键盘读入学生成绩，找出最高分，并输出学生成绩等级
*/
import java.util.Scanner;
public class TestStudentScore {
public static void main(String[] args){
//1.创建Scanner的对象，从键盘获取学生成绩
Scanner s = new Scanner(System.in);
System.out.println("请输入学生个数:");
int count = s.nextInt();
//2.根据学生个数n，创建一个长度为n的int型的数组
int[] scores = new int[count];
int maxScore = 0;
//3.依次从键盘获取n个学生的成绩，并赋给相应的数组元素，并获取最高分
for (int i = 0;i<scores.length;i++){
int score = s.nextInt();
scores[i] = score;
if(scores[i]>maxScore){
maxScore = scores[i];
}
}
//4.遍历学生成绩的数组，并根据成绩与最高分的差值，赋予评级并输出
System.out.println("最高分为："+maxScore);
for(int i =0;i<scores.length;i++){
char level;
if(scores[i]>=maxScore-10){
level = 'A';
}else if(scores[i]>=maxScore-20){
level = 'B';
}else if(scores[i]>=maxScore-30){
level = 'C';
}else
level = 'D';
System.out.println("student"+i+"score"+scores[i]+"grade is"+level);
}
}
}
- 感悟：Scanner与数组赋值配套使用！
4 多维数组
4.1 基本代码格式
4.1.1练习（上述题目）
public class TestArry3 {
public static void main(String[] args){
int [][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[2];
arr[2] = new int[4];
arr[0][0] = 3;
arr[0][1] = 8;
arr[0][2] = 2;
arr[1][0] = 2;
arr[1][1] = 7;
arr[2][0] = 9;
arr[2][1] = 0;
arr[2][2] = 1;
arr[2][3] = 6;
int sum=0;
for (int m = 0;m<arr.length;m++){
for (int n = 0;n<arr[m].length;n++){
sum +=arr[m][n];
}
}
System.out.println("所有元素和为："+sum);
}
}
4.2 多维数组的内存结构
4.3基本代码
public class TestArry2 {
public static void main(String[] args){
int [] score = new int[10];
int [] [] score1;
String[][] names;
//1.二维数组的初始化
score1 = new int[][]{{1,2,3},{2,3,4},{5,4,6}};//静态初始化！
//names = new String[6][5];//动态初始化！
names = new String[6][];//动态初始化！在不明白每个小组多少人的情况下
names[0] = new String[5];
names[1] = new String[4];
names[2] = new String[7];
names[3] = new String[5];
names[4] = new String[8];
names[5] = new String[5];
//2.如何来引用具体的某一个元素
int[][] i = new int[3][2];// 同：int[] i[] = new int[3][2];
i[1][0] = 90;
i[2][0] = 89;
//3.数组的长度，length调用
System.out.println(i.length);//3
System.out.println(i[0].length);//2
System.out.println(names[4].length);//8
//4.如何遍历二维数组（嵌套for循环！）
for (int m=0;m<score1.length;m++){
for (int n = 0;n<score1[m].length;n++){
System.out.print(score1[m][n]+" ");
}
System.out.println(" ");
}
}
}
4.4 数组异常问题
- 下标越界异常
- 空指针异常
public class TestException {
public static void main(String[] args){
//1.数组下标越界异常 java.lang.ArrayIndexOutOfBoundsException
int[] i =new int[10];
/*
i[0] = 90;
i[10] = 99;
for(<=i.length)
*/
//2.空指针异常(赋值之后，指针没有了) java.lang.NullPointerException
//第一种：
/*
boolean[] b = new boolean[3];
b = null;
System.out.println(b[0]);
*/
//第二种： .toString() 调用方法；str[3]为方法；
/*
String[] str = new String[4];
str[3] = "AA";
System.out.println(str[3].toString()); //null 本身为空指针
*/
//第三种：
int[][] j = new int[3][];
j[2][0] = 11;
}
}
4.5二维数组练习
（1）数组之间赋值规则
（2）使用二维数组打印杨辉三角
/*
杨辉三角打印！
* 1
* 11
* 121
* 1331
* 14641
* .......
* */
public class TestYangHui {
public static void main(String[] args){
//1.初始化二维数组！
int[][] yangHui = new int[10][];
for (int i = 0;i<yangHui.length;i++){
yangHui[i] = new int[i+1];
}
//3.赋值！
for(int i = 0;i<yangHui.length;i++){
for (int j =0;j<yangHui[i].length;j++){
yangHui[i][0] = yangHui[i][i] = 1;
if (i>1 && j<i && j>0){
yangHui[i][j] = yangHui[i-1][j] + yangHui[i-1][j-1];
}
}
}
//2.遍历二维数组！
for (int i = 0;i<yangHui.length;i++){
for(int j = 0;j<yangHui[i].length;j++){
System.out.print(yangHui[i][j]+"\t");
}
System.out.println();
}
//
}
}
结果：
4.6 数组的常用算法
1.求数组元素的最大值、最小值、平均数、总和等
public class TestArry4 {
public static void main(String[] args){
int[] arr = new int[]{12,43,9,0,-65,-99,100,9};
//1.最大值
int max = arr[0];
for (int i = 1;i<arr.length;i++){
if (max < arr[i]){
max = arr[i];
}
}
System.out.println("数组的最大值为："+max);
//2.最小值
int min = arr[0];
for (int i =1;i<arr.length;i++){
if (min> arr[i]){
min = arr[i];
}
}
System.out.println("数组的最小值为："+min);
//3.总和
int sum =arr[0];
for (int i =1;i<arr.length;i++){
sum += arr[i];
}
System.out.println("数组总和为："+sum);
//4.平均数
float average =0.0f;
average = (float)sum/arr.length;
System.out.println("平均数为："+average);
}
}
2.数组的复制、反转
package com.atguigu.exer;
/*
使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
*/
public class TestArry1 {
public static void main(String[] args){
int[] arry1,arry2;
arry1 = new int[]{2,3,5,7,11,13,17,19};
for (int i = 0;i<arry1.length;i++){
System.out.print(arry1[i]+"\t");
}
System.out.println();
arry2 = arry1;
for (int i =0;i<arry2.length;i++){
if(i%2 == 0){
arry2[i] = i;
}
System.out.print(arry1[i]+"\t");
}
}
}
- 问题：数组的赋值不应该用arry1 = arry2；
- 因为这样是铜过指针赋值，导致两个数组同时变化
- 使用sout（arry1）即可打印地址，显示两者地址相同！
- 数组元素赋值要改成：
arry2 = new int[arry1.length];
for (int i =0;i<arry2.length;i++){
arry2[i] = arry1[i];
if(i%2 == 0){
arry2[i] = i;
}
System.out.print(arry2[i]+"\t");
}反转法1：
public class TestArry1 {
public static void main(String[] args){
int[] arry1,arry2;
arry1 = new int[]{2,3,5,7,11,13,17,19};
for (int i = 0;i<arry1.length;i++){
System.out.print(arry1[i]+"\t");
}
System.out.println();
//数组反转
for (int i =0;i<arry1.length/2;i++){
int temp = arry1[i];
arry1[i] = arry1[arry1.length-1-i];
arry1[arry1.length-1-i] = temp;
}
//遍历
for (int i =0;i<arry1.length;i++){
System.out.print(arry1[i]+"\t");
}
}
}反转法2 ：
for (int x =0,y=arry1.length-1;x<y;x++,y--){
int temp =arry1[x];
arry1[x] = arry1[y];
arry1[y] = temp;
}3.数组元素的排序
插入排序
- 直接插入排序、折半插入排序、Shell排序
交换排序
- 冒泡排序、快速排序（或分区交换排序）
选择排序
- 简单选择排序、堆排序
归并排序
基数排序
（1）冒泡排序
- 从数组初始端，两个进行大小比较，大的交换位置，每次产生一个做大值，依次进行；（从小到大排序）
//冒泡排序！
public class Sort {
public static void main(String[] args){
int[] arr = new int[]{12,1,5,9,4,3,6,5,7};
for (int i =0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
for(int i =0;i<arr.length-1;i++){
for (int j = 0;j<arr.length-i-1;j++){
if (arr[j] > arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for (int i =1;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}
（2）直接选择排序
从第一个数开始，依次和后面的数进行比较，选择出最小的放在第一位；
//直接选择排序！从小到大排序
for (int i =0;i<arr.length-1;i++){
for (int j = i;j<arr.length;j++){
if (arr[i]>arr[j]){
int temp =arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
System.out.println();
for(int i =0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
改良版：
//直接选择排序！从小到大排序
for (int i =0;i<arr.length-1;i++){
int t = i; //1.默认i处为最小
for (int j = i;j<arr.length;j++){
//2.一旦出现比其小的元素，记录角标
if (arr[t]>arr[j]){
t = j;
}
}
//3.赋值
if ( t != i){
int temp = arr[t];
arr[t] = arr[i];
arr[i] = temp;
}
}
System.out.println();
for(int i =0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}（3）java内置的Arry类里面的sort方法
Arrys.sort 调用：从小到大
import java.util.Arrays;
//冒泡排序！
public class Sort {
public static void main(String[] args){
int[] arr = new int[]{12,1,-5,9,4,3,6,5,7};
Arrays.sort(arr);
for (int i = 0;i<arr.length;i++){
System.out.print(arr[i]+"\t");
}
}
}4.补充排序算法知识点
1.数据结构：现实的数据元素之间有着纷繁复杂的逻辑关系，需要采用合适的物理结构来存储这些数据，并以此为基础对这些数据进行相应的操作。同时，还要分析这些数据结构在时间、空间上的开销的优劣。这种专门研究应用程序中数据之间逻辑关系、存储方式及其操作的学问就是数据结构。
（1）逻辑结构：数据元素之间存在的关联关系被称为数据的逻辑结构归纳起来，应用程序中的数据大致有如下四种基本逻辑结 构
集合、线性关系、树形结构、图状结构或者网状结构（算法设计取决于逻辑结构；算法的实现依赖于存储结构）
（2）排序
衡量排序算法的优劣：
1.时间复杂度：分析关键字的比较次数和记录的移动次数
2.空间复杂度：分析排序算法中需要多少辅助内存
3.稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。
排序算法分类：内部排序和外部排序
1.内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成。
2.外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器（如磁盘）。外部排序最常见的是多路归并排序。可以认为外部排序是由多次内部排序组成。
常用的内部排序：
1.选择排序
直接选择排序、堆排序
2.交换排序
冒泡排序、快速排序
3.插入排序
直接插入排序、折半插入排序、Shell排序
4.归并排序
5.桶式排序
6.基数排序
选择排序：
将待排序的元素分为已排序（初始为空）和未排序两组，依次将未排序的元素中值最小的元素放入已排序的组中。直接选择排序简单直观，但性能略差；堆排序是一种较为高效的选择排序方法，但实现起来略微复杂
直接选择排序：
堆排序：
冒泡排序：
快速排序：
插入排序：
归并排序：
桶式排序
基数排序
扫一扫
2279
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
