数组、结构、排序
数组
数组的定义
数组类型 数组名[] = new 数据类型[大小]
int a[] = new int[5];//创建了一个数组， 名字a，存放5个int
数组的引用（使用/访问/获取数组元素）
数组名[下标/索引/index] 比如，你要使用a数组的第3个值 a[2]
动态初始化
1.先声明数组
语法：数据类型 数组名[]； 数据类型[] 数组名；
int a[];或 int[] a;
2.创建数组
语法：数组名=new 数据类型[大小]
a=new int[10];
静态初始化
语法：数据类型 数组名[]={元素值，元素值...}
int a[]={1,2,3,4,5}相当于
int a[] = new int[5];
a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;
数组注意事项
1.数组是多个相同类型的数据的组合，实现对这些数据的统一管理
2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
3.数组创建后，如果没有赋值，有默认值
int 0,short 0,byte 0,long 0,float 0.0,double 0.0,char \u0000,boolean false,String nul
4.使用数组的步骤1.声明数组并开辟空间；2.给数组各个元素赋值；3.使用数组
5.数组的下标是从0开始的
6.数组下标必须在指定范围内使用，否则报：下标越界异常，比如
int[] arr=new int[5];则下标有效为0~4
7.数组属引用类型，数组型数据是对象（object）
数组赋值机制
基本数据类型赋值，赋值的方式为值拷贝，n2的变化不会影响n1的值；
数组是在默认情况下引用传递，赋的是值的地址，赋值方式为引用传递，是一个地址 arr2变化会影响到arr1；
import java.util.Scanner;
public class Array02 {
public static void main(String[] args) {
//基本数据类型赋值，赋值的方式为值拷贝
//n2的变化不会影响n1的值
int n1 = 10;
int n2 = n1;
n2 = 20;
System.out.println("n1="+n1);//n1=10
System.out.println("n2="+n2);//n2=80
//数组是在默认情况下引用传递，赋的是值的地址，赋值方式为引用传递
//是一个地址 arr2变化会影响到arr1
int[] arr1={1,2,3};
int[] arr2=arr1;
arr2[0]=20;
for (int i = 0;i< arr1.length;i++){
System.out.println("arr1="+arr1[i]);
}
}
}数组拷贝
public class Array01 {
public static void main(String[] args){
//将int[] arr1 = {10,20,30};拷贝到arr2数组，要求数据空间是独立的
int[] arr1={10,20,30};
int[] arr2=new int[arr1.length];
for (int i = 0;i < arr1.length;i++){
arr2[i]=arr1[i];
}
arr2[0]=100;
for (int i=0;i<arr1.length;i++){
System.out.println("arr1="+arr1[i]);
}
for (int i=0;i<arr2.length;i++){
System.out.println("arr2="+arr2[i]);
}
}
}数组翻转
import java.util.Scanner;
public class Array02 {
public static void main(String[] args) {
//要求把arr = {11,22,33,44,55,66}中的内容翻转->66,55,44,33,22,11
int[] arr = {11,22,33,44,55,66};
int temp=0;
int len=arr.length;
for (int i = 0;i< len/2;i++){
temp = arr[len-1-i];
arr[len-1-i]=arr[i];
arr[i]=temp;
}
for (int i=0;i <arr.length;i++){
System.out.println(arr[i]);
}
}
}数组扩容
public class Array02 {
public static void main(String[] args) {
/*
* 要求：实现动态的给数组添加元素效果，实现对数组扩容
* 1.原始数组使用静态分配 int[] arr ={1,2,3}
* 2.增加的元素4，直接放在数组的最后 arr={1,2,3,4}
* 3,用户可以通过如下方法来决定是否继续添加，添加成功，是否继续y/n？
* 思路分析
* 1.定义初始数组int[] arr ={1,2,3}；
* 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;原来的arr数组被销毁*/
int[] arr ={1,2,3};
int[] arrNew = new int[arr.length+1];
for (int i=0;i<arr.length;i++){
arrNew[i]=arr[i];
}
arrNew[arrNew.length-1]=4;
arr=arrNew;
for (int i = 0;i<arr.length;i++){
System.out.println("arr=" + arr[i]);
}
}
}排序
排序介绍：
排序是将多个数据，依指定的顺序进行排列的过程
排序的分类：
1.内部排序，指将需要处理的所有数据都加载到内部存储器中进行排序。包括（交换式排序法，选择式排序法和插入式排序法）；
2.外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）；
冒泡排序法(Bubble Sorting)
基本思想：通过对待排序序列从后向前(从下标较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
总结冒泡排序特点：
1.一共有5个元素
2.一共进行了4轮循环，可以看成使外层循环
3.每一轮排序可以确定一个数的位置，比如第一轮排序确定最大数，第二轮排序确定第二大数的位置，以此类推
4.当进行比较时，如果前面的数小于后面的数就交换
public class Input {
public static void main(String[] args){
/*数组[24，69，80，57，13]
第一轮排序：目标把最大数放在最后
第一次比较[24，69，80，57，13]
第二次比较[24，69，80，57，13]
第三次比较[24，69，57，80，13]
第四次比较[24，69，57，13，80]
*/
int[] arr = {24,69,80,57,13};
int temp = 0;//用于辅助交换变量
for (int i = 0;i < arr.length-1;i++) {//外层循环是4次
for (int j = 0; j < arr.length-1-i; j++) {
//if前面的数>后面的数就交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("\n==第"+(i+1)+"轮==");
for (int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + "\t");
}
}
}
}查找
顺序查找
import java.util.Scanner;
public class SeqSearch {
public static void main(String[] args){
/*有一个数列：白眉鹰王，金毛狮王，紫衫龙王，青翼蝠王猜数游戏：
* 从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
* 要求，如果找到了，就提示找到，并给出下标
* 思路：
* 1.定义一个字符串数组
* 2.接收用户输入，遍历数组，逐一比较，如果有，则提示信息，并退出*/
String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入信息：");
String findName = scanner.next();
int index = -1;//使用index索引退出
for (int i = 0;i < names.length;i++){
if (findName.equals(names[i])){
System.out.println("恭喜你找到"+findName);
System.out.println("下标为"+ i );
index = i;//把i保存到index
break;//退出
}
}
if (index == -1){
System.out.println("未找到"+findName);
}
}
}二分查找
多维数组
二维数组
public class Input {
public static void main(String[] args){
/*请用二维数组输出如下图案
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0
思路：
1.从定义形式上看int[][]
2.原来的一维数组的每个元素都是一维数组，就构成了二维数组
*/
int[][] arr={
{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 < arr.length;i++){//遍历二位数组的每个元素
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：动态初始化
1.先声明：类型 数组名[] [];
2.再定义(开辟空间) 数组名 = new 类型[大小] [ 大小]
3.赋值(有默认值，比如int 类型的就是0)
使用方式3：动态初始化-列数不确定
1.看一个需求，动态创建下面的二维数组，并输出
| j=0 | j=1 | j=2 | |
|---|---|---|---|
| i=0 | 1 | ||
| i=1 | 2 | 3 | |
| i=2 | 3 | 3 | 3 |
public class Input {
public static void main(String[] args) {
int[][] arr = new int[3][];//定义一个二维数组，但只确定一维数组的个数
for (int i = 0;i < arr.length;i++){//遍历arr的每一个数组
//给每个一维数组开辟空间 new
//如果没有给一维数组new arr[i]就是null
arr[i] = new int[i+1];
//遍历一维数组，并给每一个元素赋值
for (int j = 0;j< arr[i].length;j++){
arr[i][j]=i+1;
}
}
//遍历arr输出
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();
}
}
}使用方式4：静态初始化
定义： 类型 数组名[] [] = {{值1，值2...}，{值1，值2...}，{值1，值2...}，{值1，值2...}}
使用即可[固定方式访问]
二维数组使用细节和注意事项
1.一维数组的声明方式
int[] x或者 int x[];
2.二维数组的声明方式有
int[] [] y或者int[] y[]或者int y[] [];
3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不同。
比如：map[] []是一个二维数组
由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
