Java第五天
数组
介绍
数组可以存放多个同一类型的数据。数组也是一周数据类型，是引用类型。
即：数(数据)组(一组)就是一组数据
//1.double[]表示 是double类型的数组，数组名是 hens
//2.{3,5,1,3.4,2,50}表示数组的值或者元素，依次表示数组的第几个元素
double[] hens = {3,5,1,3.4,2,50};
//遍历数组得到数组的所有元素的和，使用for循环遍历
//1.我们可以通过hens[下标]来访问数组的元素，下标是从0开始编号的，
//比如第一个元素就是hens[0] 第二个元素就是hens[1]，以此类推
//2.通过for就可以循环的访问数组的元素/值
//3.使用一个变量totalWeight将各个元素累计
double totalWeight = 0;
for(int i = 0; i < 6; i++){
System.out.println("第"+(i+1)+"个元素的值为"+hens[i]);
totalWeight += hens[i];
}
数组的使用
使用方式1-动态初始化
数组的定义
数据类型 数组名[] = new 数据类型[大小]
int a[] = new int[5];//创建了一个数组，名字为a，存放5个int
这是定义数组的一种方法
数组的引用(使用)
数组名[下标/索引]
比如：要使用a数组的第3个数 a[2]
import java.util.Scanner;
public class Array02{
public static void main(String[] args) {
//演示
//循环输入5个成绩，保存到double数组，并输出
//1.创建一个double数组，大小为5
double scores[] = new double[5];
//2.循环输入
Scanner myScanner = new Scanner(System.in);
// socres.leng表示数组的大小
for(int i = 0; i < scores.length; i++){
System.out.print("请输入第"+(i+1)+"个同学的成绩");
scores[i] = myScanner.nextDouble();
}
//3.输出，遍历数组
System.out.println("同学们的成绩情况如下");
for(int i = 0; i < scores.length; i++){
System.out.println("第"+(i+1)+"个同学的成绩为"+scores[i]);
}
}
}
使用方式2-动态初始化
先声明数组
语法：数据类型 数组名[]；也可以 数据类型[] 数组名;
int a[]; 或者 int[] a;
创建数组
语法：数组名 = new 数据类型[大小];
a = new int[10];
int a[];
a = new int[]
使用方式3-静态初始化
初始化数组
语法：数据类型 数组名[] = {元素值，元素值…}
int a[] = {2,5,6,7,90};
double hens[] = {3,5,1,3.4,2,50};
//等价于 hens[] = new double[6];
//hens[0] = 3; hens[1] = 5; hens[2] = 1; hens[3] = 3.4; hens[4] = 2; hens[5] = 50;
数组使用注意事项和细节(ArrayDetail.java)
- 数组是多个相同类型数据的组合，实现对这些数据的统一管理
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
- 数组创建后，如果没有赋值，有默认值 int 0，short 0，byte 0，long 0，float 0.0，double 0.0，char \u0000，boolean false，String null
- 使用数组的步骤
- 声明数组并开辟看见
- 给数组各个元素赋值
- 使用数组
- 数组的下标是从0开始的
- 数组下标必须在指定范围内使用，否则报：下标越界异常
- 数据属引用类型。数组型数据是对象(object)
public class ArrayDetail{
public static void main(String[] args) {
//1.数组是多个相同类型数据的组合，实现对这些数据的统一管理，不能混用
//int[] arr1 = {1,2,3,60,1.1,"hello"};//错误,不能使double 和 String类型赋给int
double[] arr2 = {1,2,3,60,1.1};
//2.数组中的元素可以是任何数据类型，包括基本类型和引用类型
String[] arr3 = {"北京","jack","milan"};
//3.数组创建后，如果没有赋值，有默认值
//int 0，short 0，byte 0，long 0，float 0.0，
//double 0.0，char \u0000，boolean false，String null
short[] arr4 = new short[4];//此时数组里面的四个位置都是0
for(int i = 0; i < arr4.length; i++){
System.out.println(arr4[i]);//输出四个0
}
//6.数组下标必须在指定范围内使用，否则报：下标越界异常
int [] arr5 = new int[5];
System.out.println(arr5[5]);//数组越界
}
}
数组赋值机制
-
基本数据类型赋值，这个值就是具体的数据，而且相互不影响
int n1 = 10; int n2 = n1; n2 = 80; System.out.println("n1 = "+n1);//n1 = 10 System.out.println("n2 = "+n2);//n2 = 80 -
数组在默认情况下是引用传递，赋的值是地址
int[] arr1 = {1,2,3}; int[] arr2 = arr1; arr2[0] = 10; System.out.println("arr1[0] = "+arr1[0]);//10
数组的拷贝(ArrayCopy.java)
public class ArrayCopy{
public static void main(String[] args) {
//将 int[] arr1 = {10,20,30};拷贝到arr2数组
//要求数据空间是独立的
int[] arr1 = {10,20,30};
//创建一个新的数组arr2，开辟新的数组看见
//大小为arr1.length
int[] arr2 = new int[arr1.length];
//遍历arr1，把每个元素拷贝到arr2对应的元素位置
for(int i = 0; i < arr1.length; i++){
arr2[i] = arr1[i];
}
arr2[0] = 100;
System.out.println("====arr1的元素====");
for(int i = 0; i < arr1.length; i++){
System.out.println(arr1[i]);//10,20,30
}
System.out.println("====arr2的元素====");
for(int i = 0; i < arr2.length; i++){
System.out.println(arr2[i]);//100,20,30
}
}
}
数组添加(ArrayAdd.java)
要求：实现动态的给数组添加元素效果，实现队数组的扩容|
- 原始数组使用静态分配Int[] arr = {1,2,3}
- 增加的元素4要放在数组的最后使得arr = {1,2,3,4}
- 用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
import java.util.Scanner;
public class ArrayAdd{
public static void main(String[] args) {
//思路分析
//1.定义初始数组 int[] arr = {0,1,2}//下标0-2
//2.定义一个新的数组 int[] arrNew = new int[arr.length+1];
//3.遍历arr数组,依次将arr的元素拷贝到arrNew数组
//4.将4赋给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个要素
//5.让arr指向arrNew; arr = arrNew;
//6.创建一个Scanner可以接受用户输入
//7.因为用户什么时候退出，不确定，所以用do while循环+break控制
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3};
do{
int[] arrNew = new int[arr.length+1];
//因为arrNew是在dowhile循环这个里面的作用域
//所以循环一次后就不存在arrNew这变量
//所以就不存在重复声明变量的错误
for (int i = 0; i < arr.length ; i ++ ) {
arrNew[i] = arr[i];
}
System.out.print("请输入你要添加的元素：");
int addNum = myScanner.nextInt();
arrNew[arrNew.length - 1] = addNum;
arr = arrNew;
System.out.print("arr扩容后的情况");
for (int i = 0; i < arrNew.length ; i++){
System.out.print(arr[i] + "\t");
}
System.out.print("添加成功，是否继续？y/n \t");
char c1 = myScanner.next().charAt(0);
if(c1 == 'n'){
break;
}
}while(true);
}
}
数组删减(ArrayReduce.java)
import java.util.Scanner;
public class ArrayReduce{
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3,4,5,6};
int j = 1;
do{
int[] arrNew = new int[arr.length - 1];
int k = 1;
while(j != 0){
System.out.print("你是否想删除arr数组的最后一个元素？y/n \t");
char c1 = myScanner.next().charAt(0);
if(c1 == 'n'){
k = 0;
break;
}
j--;
}
if(k == 0){
break;
}
for (int i = 0; i < arr.length - 1; i++ ) {
arrNew[i] = arr[i];
}
arr = arrNew;
System.out.println("删除成功，arr数组如下");
for (int i = 0; i < arr.length; i++ ) {
System.out.print(arr[i]+"\t");
if(i == arr.length - 1){
System.out.println("");
}
}
while(j == 0){
System.out.print("你是否想继续删除arr数组的最后一个元素？y/n\t");
char c1 = myScanner.next().charAt(0);
if(c1 == 'n'){
k = 0;
break;
}
break;
}
if(k == 0){
break;
}
}while(true);
}
}
排序
排序是将多个数据，依指定的顺序进行排列的过程
排列的分类：
- 内部排序：
指将需要处理的所有数据都加载到内部存储器中进行排序。包括 交换式排序法、选择式排序法 和 插入式排序法 - 外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括 合并排序法 和 直接合并排序法
冒泡排序法
基本思想：通过对待排序序列从后向前(从下标较大的元素开始)，依次比较响铃元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒
特点：
- 一共5个元素
- 一共进行4论排序，可以看成是外层循环
- 每一轮排序可以确定一个数的位置，比如第一轮排序确定最大数
- 当进行比较时，如果前面的数大于后面的数就交换
- 每轮比较次数在减少4 >> 3 >> 2 >> 1
public class BubbleSort{
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
int temp = 0;
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
if(arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("\n==第"+(arr.length-i)+"轮==");
for(int j = 0; j < arr.length; j++){
System.out.print(arr[j] + "\t");
}
}
}
}
二维数组
二维数组本质上是以数组作为数组元素的数组，即“数组的数组”
类型说明符 数组名 [常量表达式][常量表达式]。
二维数组又称为矩阵，行列数相等的矩阵称为方阵
public class TwoDimensionalArray01{
public static void main(String[] args) {
int[][] arr = {{0,0,0,0,0,0},{0,0,0,1,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
//输出二维图像
for(int i = 0; i < arr.length; i++){
//遍历二位数组的每个元素
//1. arr[i]表示二维数组的第i+1个元素
//2. arr[i].length 得到对应的 每个一维数组的长度
for (int j = 0; j < arr[i].length ; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println("");
}
}
}
使用方式1：动态初始化
语法：类型[][] 数组名 = new 类型[大小][大小]
int[][] a = new int[2][3];
使用方式2：动态初始化
- 先声明： 类型 数组名[][];
- 再定义：数组名 = new 类型[大小][大小]
如果想要每列的数组长度不一样，对一维数组的大小可以先空着(第二个中括号空着)，在二维数组定义后时才进行开拓 - 赋值(有默认值，比如int类型的默认值就是0)
int arr[][];
arr = new int[5][5]
使用方式3：静态初始化
语法： 类型 数组名[][] = {{值1，值2…},{值1，值2…},{值1，值2…}…}
int[][] arr = {{1,1,1},{8,8,9},{100}};
1136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
