JAVA学习笔记——第六章 数组
博客主页： A_SHOWY
系列专栏：力扣刷题总结录 数据结构 云计算 数字图像处理 力扣每日一题_
数组可以存放多个同一类型的数据，是一种数据类型，是引用类型
即：数组就是一组数据
double total = 0;
double[] hens = {1,2.1,3.2,5,6,7,9};
for(int i = 0; i < 7; i++){
total += hens[i];
System.println.out("total");
}数组的长度：数组名.length。
数组的使用
使用方式1： 动态初始化
数组的定义：数据类型 数组名【】 = new 数据类型【大小】例：int a【】= new int【5】；
数组的引用（使用）： 数组名【index】 a【2】（获取第三个元素）
例：
import java.util.Scanner;
public class shuzu1 {
public static void main(String[] args){
//输入
double scores[] = new double[5];
Scanner myscanner = new Scanner(System.in);
for(int i = 0; i < scores.length;i++){
System.out.println("请输入第" + (i+1) + "个元素的值");
scores[i] = myscanner.nextDouble();
}
//输出
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】
使用方式3： 静态初始化
初始化数组：数据类型数组名【】 = {元素值，元素值。。。。}
数组的注意事项
- 数组是多个相同类型数据的组合，实现针对数据统一管理
- 数组元素可以是任何数据类型，也可以放引用数据类型
- 数组创建后没有确定的值，有默认值：int：0，short：0，byte：0，long：0，float：0.0，double：0.0，char：0000，boolean：false，String： null
- 使用数组的步骤，先声明数组开辟空间，然后给各个元素赋值，最后使用
- 数组的下标从0开始，数组必须指定范围，不能越界
- 数组是引用类型，数组型数据是对象
例：
import java.util.Scanner;
public class shuzu2 {
public static void main(String[] args){
//输入
char[] chars = new char[26];
for(int i = 0; i < chars.length;i++){
chars[i] = (char)('A' + i);//'A' + i 是int类型，需要强制类型转换
}
//输出
for(int i = 0; i < chars.length; i++){
System.out.println(chars[i]);
}
}
}
例2：
import java.util.Scanner;
public class shuzu3 {
public static void main(String[] args){
int[] arr = {4,-1,9,10,23};
int Max = arr[0];
int index = 0;
for(int i = 0; i< 5; i++){
if(arr[i] > arr[index]){
Max = arr[i];
index = i;
}
}
System.out.println(Max);
System.out.println(index);
}
}
数组赋值机制
基本数据类型赋值的时候，这个值就是具体的数值且互不影响，赋值方式是值拷贝。而数组在默认情况下是引用传递，赋值是地址，赋值方式为为引用拷贝。
import java.util.Scanner;
public class shuzu4 {
public static void main(String[] args){
int arr1[] = {1,2,3};
int arr2[] = arr1;
arr2[0] = 10;
//看看arr1的值
for(int i = 0; i < 3; i++){
System.out.println(arr1[i]);
}
}
}
局部变量在栈内存，堆内放实例变量，方法区放静态变量，类方法
在内存里面只要分配了一个空间，一定会有一个地址
数组拷贝
实现数组拷贝，进行一个内容的复制
int arr1[] = {1,2,3};
int arr2[] = arr1;
int arr3[] = new int[arr1.length];//数组拷贝
for(int i = 0; i < arr3.length; i++){
arr1[i] = arr3[i];
}
数组逆转
import java.util.Scanner;
public class shuzu5 {
public static void main(String[] args){
int arr[] = {11,22,33,44,55,66};
int arr1[] = new int[arr.length];
for(int i = arr.length -1, j = 0; i >= 0; i--, j++){
arr1[j] = arr[i];
}
arr = arr1;//让arr1指向arr 的数据空间，arr原来的数据空间就没有变量引用，就会被当成垃圾销毁
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
数组扩容
数组扩容整体是比较慢的，因为每次都要开辟一个新的空间
import java.util.Scanner;
public class shuzu6 {
public static void main(String[] args){
Scanner myscanner = new Scanner(System.in);
int arr1[] = {1,2,3};
//整体用一个do-while结构，先加一个，然后再问加不加
do{
int addarr[] = new int[arr1.length + 1];//每次添加都要开辟一个新空间，创建一个新数组
System.out.println("请输入你想要添加的数字");
int xin = myscanner.nextInt();
for(int i = 0; i < arr1.length; i++){
addarr[i] = arr1[i];
}
addarr[arr1.length] = xin;
arr1 = addarr;
//查看扩容后
for(int i = 0; i < arr1.length; i++){
System.out.println(arr1[i]);
}
System.out.println("请输入y/n表示是否还要增加元素");
char a = myscanner.next().charAt(0);
if(a == 'n') break;
}
while(true);
}
}
冒泡排序
冒泡排序：通过对待排序列从后向前，依次比较相邻元素的值，若发现逆序则交换，使数值较大的元素逐渐从前移到后部。
思路：
灵活的冒泡排序实现：
import java.util.Scanner;
public class maopao {
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入想要排序的数组元素个数");
int num = scanner.nextInt();
int arr[] = new int[num];
//输入想要的数组的每一个元素
for(int i = 0; i < num; i++){
System.out.println("请输入第" + (i+1) +"个元素");
int num1 = scanner.nextInt();
arr[i] = num1;
}
//外层代表循环次数
for(int k = 1; k < num; k++) {
for (int i = 0,j = 1; i <= (num - k - 1); i++, j++) {
if (arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
System.out.print("==第" + k + "次循环==");
for(int i = 0 ; i < num; i++){
System.out.print(arr[i] + " ");
}
System.out.println('\n');
}
}
}
查找
1.顺序查找
2.二分查找：要求是有序的
二维数组
形式：int【包含几个一维数组】【每个一维数组包含几个元素】 ，二维数组可以理解为每一个元素都是一维数组
二维数组输出：
import java.util.Scanner;
public class erweishuzu {
public static void main(String[] args){
int a[][] = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
for(int i = 0; i < a.length; i++){
for(int j = 0; j < a[i].length; j++){
System.out.print(a[i][j]);
}
//换行
System.out.println();
}
}
}
二维数组的使用
使用方式1：动态初始化
类型【】【】 = new 类型 【大小】【大小】 例：int a【】【】=new int【2】【3】
使用方式2：动态初始化
先声明再初始化，和一维很类似
使用方式3：动态初始化-列数不确定
import java.util.Scanner;
public class shuzu7 {
public static void main(String[] args){
int[][] arr = new int[3][];//每个一维数组还没有开数据空间
for(int i = 0; i < arr.length; i++){//遍历每一个一维数组
arr[i] = new int[i + 1];//给每一个一维数组开空间new
for(int j = 0; j < arr[i].length; j++){//遍历每个一维数组，并给他们赋值
arr[i][j] = i + 1;
}
}
}
}
使用方式4：静态初始化
和一维数组的非常相似 .
杨辉三角
杨辉三角就用到这种列数不确定
import java.util.Scanner;
public class yanghui {
public static void main(String[] args){
int[][] yanghui= new int [5][];
for(int i = 0; i < yanghui.length; i++){//遍历yanghui的每个元素
//给每一个一维数组开辟空间
yanghui[i] = new int[i + 1];
//给每个一维数组赋值
for(int j = 0; j < yanghui[i].length; j++){
if(j == 0 || j == yanghui[i].length -1){
yanghui[i][j] = 1;
}
else{
yanghui[i][j] = yanghui[i - 1][j] + yanghui[i - 1][j - 1];
}
}
}
//输出
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();//空格
}
}
}
练习1：
C选项之所以错了是可以理解为new的是一个String你初始化为{}是一个数组，所以不对。
练习2（重要）：
有两种思路，第一种是先扩容以后再冒泡排序
import java.util.Scanner;
public class zuoye3 {
public static void main(String[] args){
int[] arr= {10,12,45,90};
//先扩容
int[] arr1 = new int[arr.length + 1];
for(int i = 0; i arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for(int i = 0; i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}
第二种思路是先找到这个添加的地方，先定位，这个定位操作用到一个index = -1考虑到有可能插入到最后，然后进行插入
import java.util.Scanner;
public class zuoye3_2 {
public static void main(String[] args){
int arr[] = {10,12,45,90};
int insertNum = 23;
int index = -1;
//先找index位置
for(int i = 0; i < arr.length;i++){
if(insertNum <= arr[i]){
index = i;
break;
}
}
//index可能是最大的
if(index == -1){
index = arr.length;
}
//插入
int arrnew[] = new int[arr.length + 1];
for(int i = 0, j = 0;i < arrnew.length;i++){
if(i != index){
arrnew[i] = arr[j];
j++;
}
else{
arrnew[i] = insertNum;
}
}
arr = arrnew;
//输出
for(int i = 0; i < arr.length;i++){
System.out.print(arr[i] + "\t");
}
}
}