一、存储数据：
- 变量：一个变量只能存储一个数据（一个椅子）
如存储姓名、年龄、成绩这几个不相干的内容可以为每个内容单独声明变量 - 数组：一个数组可以存储多个数据（一排连续的凳子）
如同时存储5个成绩（同一种类型），可以使用数组
二、认识数组
- 数组占用了内存中的一组连续在一起的多个空间，所以可以存储多个数据。
- 数组中同时存储的多个数据必须是相同的数据类型。
- 必须先声明并分配长度（最多能容纳的数据的个数）才能使用
int num = 100;或者 int num = scan.nextInt(); //变量的声明，1个名对应一个值
-> nt num[] = { 1,4,5,8,2,6 }; ----num数组是一个长度为6的数组,并赋值
数组的空间是静态分配的，声明数组的空间大小后，在程序执行过程中只能使用这么些，不能再扩展了。
-> int[] arr = new int[100]; —最多能存储100个整数，声明之后没有赋值，但整型的变量默认初始值是0，小数类型的默认0.0。没有必要记每种类型默认值
-> 是什么靠多写
-> 也可以这么声明数组：int arr[] = new int[100]; - 数组元素的访问。数组中每个元素的名字都是一样的，即数组名。如果使用数组中某个数据，可以使用数组名和下标进行表示，下标是从0开始的整数。
-> int a = 100;int b = 20; 说a就代表100，说b就代表20，就好像叫名就代表了某个人。也可以说1班的0123号同学，1班的0124号同学，也都是代表了某个人（这种叫法就是数组的称呼方式）。
-> 语法：数组名[下标]—等价于变量 比如num[0]1,num[5]6,arr[9]0(默认值)
-> int[] arr = new int[100];下标从0开始，第一个元素是arr[0],最后一个是arr[99]，arr[100],越界
-> 数组中真正的难点是下标。
三、二维数组
- 二维数组的定义
如果定义一个这样的二维数组int a[3][4]={{1,3,5,7},{9,11,13,15},{17,19,21,23}};则其在内存
中的表示可能下面这样。
四、数组的排序
Java中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。
快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现
冒泡法对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序
选择排序法是最简单直观的一种算法，基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止。
插入排序插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
【程序1】熟悉数组的声明、数组元素的赋值（从键盘输入值）、运算、输出，了解数组元素等价于单个变量的作用。
public class ArrayDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 声明一个长度为5的整型数组
int[] num=new int[5];
//数组元素可以做赋值，数组元素的值可以从键盘输入，可以做运算，可以输出
//数组名[下标]等价于变量的作用
num[0] = 120; //1.可以赋值
num[1] = 900;
System.out.print("请输入一个整数");
num[2] = scan.nextInt(); //2.从键盘输入
num[3] = num[0] + num[2]; //3.可以做运算
//显示数组中的每个元素
System.out.println(num[0]); //4.可以输出
System.out.println(num[1]);
System.out.println(num[2]);
System.out.println(num[3]);
System.out.println(num[4]);
}
}
五、数组的遍历
//for循环：使用下标一个一个表示出来
for(int i=0;i<数组长度;i++){
System.out.println(数组名[i]);
}
//foreach循环：挨个遍历数组中的元素（目前仅限于数组的遍历）
for(数组类型 变量名:数组名){
System.out.println(变量名]);
}
【程序2】将程序1的数组元素的输出改写成循环（用两种方法）。
//用for循环输出数组中的每个元素
for(int i=0;i<5;i++){
System.out.println(num[i]);
}
//用foreach循环输出数组中的每个元素
for(int x:num){
System.out.println(x);
}
【程序3】声明一个字符串数组，并初始化一些顾客的名字，显示出所有顾客的名字，通过一个随机整数的产生，代表一个数组的下标，获取对应的一个顾客的名字，作为幸运者。
String[] names={"刘晓丽","徐姣","姜磊","张涛","黄久儒","林丹"};
//遍历数组，输出幸运者名字
System.out.println("本次幸运者的参与者如下：");
for(int i=0;i<6;i++){
//输出语句中(i+1)的作用：
//1.i+1为了让显示更友好
//2.i+1不改变i的值，要是真的改变必须用赋值语句i=i+1,此处没执行到赋值
//3.如果不用括号，会认为是i和1的字符串拼接，而不是数字运算
System.out.println("参与者"+(i+1)+":"+names[i]);
}
//产生一个0~5之间的随机整数
int index = (int)Math.round(Math.random()*5);
System.out.println("本次幸运者是："+names[index]);
【程序4】声明一个整型数组，可以存储多个学生的成绩，通过循环获取控制台窗口中输入的每个学生的成绩，每次循环获取一个成绩，最后显示出来每个成绩，再计算出所有成绩的平均分。
编写程序先搭整体框架，清楚了总体思路，再完善具体的细节（见下图）
完整代码如下：
import java.util.Scanner;
public class StudentScore {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//数组声明的时候必须分配长度，如果具体不知道，结合项目的数据规模估计一下
//数组声明，长度不能用变量，必须是常量
int[] score = new int[50];
String answer;
int count = 0; //下标变量
//通过循环给数组赋值，具体多少次没有定，do-while比较好
do{
//获取控制台输入的学生成绩
System.out.print("请输入这个学生的成绩：");
score[count] = scan.nextInt();
count++;
//询问是否继续下一次循环
System.out.println("是否继续输入下一个成绩？【y-是，其它-否】");
answer = scan.next();
}while("y".equalsIgnoreCase(answer));
//数组中的成绩已经赋值，成绩的个数已经知道了
System.out.println("一共有"+ count +"个学生，他们的成绩如下：");
//显示出已经有成绩的学生成绩
for(int i=0;i<count;i++){
System.out.println("第" + (i+1) + "个学生的成绩如下："+score[i]);
}
int totalScore = 0;
//计算总成绩，此处代码可以放在输入中计算，也可以显示学生总成绩中计算
for(int i=0;i<count;i++){
totalScore = totalScore+score[i];
}
//计算所有学生的平均分
float avageScore = (float) totalScore / count;
System.out.println("所有学生的平均分是："+avageScore);
}
}
【程序5】给程序4增加统计最高分的功能。
//统计学生的最高分
int maxScore=score[0];
for(int i=1;i<count;i++){
if(score[i]>maxScore){
maxScore = score[i];
}
}
System.out.println("最高分是："+ maxScore);
【程序6】编写程序DyadicArray
public class DyadicArray {
public static void main(String[] args) {
// 二维数组的声明方式：
// 数据类型 [][] 数组名称 = new 数据类型 [长度][长度] ;
// 数据类型 [][] 数组名称 = {{123},{456}} ;
/*
* int [][] arr = {{123},{456}}; //定义了两行三列的二维数组并赋值 for(int x = 0;
* x<arr.length; x++){ //定位行 for(int y = 0; y<arr[x].length; y++){
* //定位每行的元素个数 System.out.print(arr[x][y]); } System.out.println("/n");
* }
*/
int[][] num = new int[3][3]; // 定义了三行三列的二维数组
num[0][0] = 1; // 给第一行第一个元素赋值
num[0][1] = 2; // 给第一行第二个元素赋值
num[0][2] = 3; // 给第一行第三个元素赋值
num[1][0] = 4; // 给第二行第一个元素赋值
num[1][1] = 5; // 给第二行第二个元素赋值
num[1][2] = 6; // 给第二行第三个元素赋值
num[2][0] = 7; // 给第三行第一个元素赋值
num[2][1] = 8; // 给第三行第二个元素赋值
num[2][2] = 9; // 给第三行第三个元素赋值
for (int x = 0; x < num.length; x++) { // 定位行
for (int y = 0; y < num[x].length; y++) { // 定位每行的元素个数
System.out.print(num[x][y]);
}
System.out.println(""); // 换行
}
}
}
运行结果：
2. 不规则二维数组
public class DyadicArray {
public static void main(String[] args) {
//创建和打印不规则二维数组
int arr[ ][ ];
arr=new int[3][];//现在说明为不规则数组
arr[0]=new int[10];//arr[0]指向另一个一位数组
arr[1]=new int[3];
arr[2]=new int[4];
//赋值
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
arr[i][j]=j;
}
}
//输出
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
运行结果：
注：在上面中不能 int arr=new int[][3],这样会报错，这个的意思就“零行三列”
<1>利用Arrays带有的排序方法快速排序
import java.util.Arrays;
public class A {
public static void main(String[] args) {
int[] a = { 5, 4, 2, 4, 9, 1 };
Arrays.sort(a); // 进行排序
for (int i : a) {
System.out.print(i);
}
}
}
<2>冒泡排序算法: 冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序
public class A {
public static void main(String[] args) {
int[] a = { 5, 4, 2, 4, 9, 1 };
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - 1; j++) {
// 如果a[j] > a[j+1] 则交换位置
if (a[j] > a[j+1]) {
int temp = a[j+1]; // 交换位置之前，先把原有的值存放在变量中
a[j+1] = a[j];
a[j] = temp;
}
}
}
// 遍历数组
for (int i : a) {
System.out.print(i);
}
}
}
<3>选择排序算法: 选择排序是最简单直观的一种算法，基本思想为每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止.
public class A {
public static void main(String[] args) {
int[] a = { 5, 4, 2, 4, 9, 1 };
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[min] > a[j]) {
min = j;
}
}
if (min != i) {
int temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
// 遍历数组
for (int i : a) {
System.out.print(i);
}
}
}
<4>插入排序算法: 插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
public class A {
public static void main(String[] args) {
int[] a = { 5, 4, 2, 4, 9, 1 };
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j--) {
if (a[j] < a[j - 1]) {
int temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
} else
break;
}
}
// 遍历数组
for (int i : a) {
System.out.print(i);
}
}
}
扫一扫
1381
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
