java基础:数组,排序,查找

数组

数组介绍

可以存放多个同一类型的数据,数组也是一种数据类型,是引用类型

数据类型[] 数组名 = {...};

可以通过数组名.length得到数组的长度

数组使用

数组定义,引用

数据类型 数组名[] = new 数据类型[大小]

通过数组名[下标/索引/index]进行访问如a[2],从0开始

也可以先声明int arr[];

arr = new int

静态初始化 int a[]={...}相当于第一种使用方法

注意事项

1. 数组是多个相同该数据类型的集合,包括可以有自动转换的数据类型
2. 数组中的元素可以是任何数据类型包括基本数据类型和引用类型
3. 数组创建后没有赋值,则默认为0,char为/u0000,boolean为false,String null
4. 使用数组:先声明再赋值后使用
5. 从0开始
6. 数组下标不可越界
7. 数组属引用类型,数组型数据是对象

数组赋值机制

基本数据类型是拷贝赋值

而数组在默认情况下是引用传递,赋的值是地址

数组拷贝

新创建一个数组new会新开辟一个空间

数组反转

1.交换

2.逆序赋值法

数组扩容

看图思路分析

根据用户的输入进行扩容

数组缩减

排序法(冒泡):

冒泡排序:

public class bubblesort{
    public static void main(String[] args){
        int[] arr = {3,6,8,5,3,1,9,8,56};
        boolean a;
        for(int i = 0;i < arr.length - 1;i++)//排n-1个数即可,最后的数一定在顺序上
        {
            a = false;
            for(int j = 0;j < arr.length - 1 - i;j++){//比较时减去已经排序好的数,倒数第二个数会与最后一个比较,故减一
                if(arr[j] > arr[j+1]){//从小到大排序
                    int temp = arr[j];//交换
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    a = true;
                }
            }
            if(!a){//如果a非为真说明没有发生交换已经完成排序,退出程序
                break;
            }
        }
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

查找

顺序查找

import java.util.Scanner;
public class SeqSearch{
	public static void main(String[] args){
		//编写一个main方法
		String[] name = {"红楼梦","水浒传","三国演义","西游记"};
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入名字:");
		String findname = myScanner.next();
		//遍历数组
		int index = -1;//用于检测是否找到
		for(int i = 0 ;i < name.length;i++){
			//比较 字符串比较方法equals
			if(findname.equals(name[i])){
				System.out.println("恭喜你找到" + findname);
				System.out.println("下表为:" + i);
				index = i;//找到了就会改变index
				break;
			}
		}
		if(index == -1){
			System.out.println("sorry!没找到");
		}
	}
}

二分查找

后续

二维数组

入门

import java.util.Scanner;
public class TwoDimensionalArray{
	public static void main(String[] args){
		//编写一个main方法
		//二维数组
		//定义上int[][] 
		//理解:原来的一维数组的每个元素是一维数组
		int[][] arr = {{0,0,0,1,1,1,0},
						{0,3,5,6,1,5,7,3},
						{2,0,4,1,0,3,1,2},
						{1,0,3,4,5,6,8}};
		//访问arr[i][j],注意从0开始编号
		//输出二维数组
		System.out.println("二维数组的个数=" + arr.length);//换行
		System.out.println("第三个一维数组的第四个值为" + arr[2][3]);//换行
		//输出二维图形
		for(int i = 0;i < arr.length;i++){
			//遍历二维数组的每个元素
			//arr[i].length得到对应的每一个一维数组
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j]+"\t");
			}
			System.out.println();//换行
		}
	}
}

使用

1.语法:类型[][] 数组名 = new 类型[大小][大小]

也可int arr[][];//先声明

arr = new int[2][3];//在创建

2.二维数组在内存的存在形式***

3.定义一个二维数组为{{1},{2,2},{3,3,3}}

public class TwoDimensionalArray
{
	public static void main(String[] args)
	{
		//编写一个main方法
		int[][] arr = new int[3][];//
		for(int i = 0;i < arr.length;i++){
			//给每一个一维数组开空间
			//如果不开,那么arr[i]是null
			arr[i] = new int[i + 1];//第i+1个一维数组的大小为i+1
			//遍历每个一维数组并赋值
			for(int j = 0;j < arr[i].length;j++){
				arr[i][j] = i + 1;
			}
		}
		for(int i = 0;i < arr.length;i++)
		{
			//遍历二维数组的每个元素
			for(int j = 0;j < arr[i].length;j++)
			{
				System.out.print(arr[i][j]+"\t");//输出1 2 2 3 3 3
			}
		}	
	}
}

4.静态初始化

如:int[][] arr = {{1,1,1},{8,9,8},{100}};

杨辉三角

public class YangHui{
	public static void main(String[] args){
		/*打印杨辉三角7行
		1
		11
		121
		1331
		14641
		...找规律,2=1+1,3=1+2,2=2+1,4=1+4,6=3+3,...体现在数组中即arr[i][j]=arr[i-1][j-1]+arr[i-1]arr[j]
		*/
		int[][] yanghui = new int[7][];
		for(int i = 0;i < yanghui.length;i++){
			//需要给每一维数组开辟空间
			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();//换行
		}
	}
}

二维数组使用细节和注意事项

一维数组可以 int[] x or int x[]

二维数组int[][] y or int[] y[] 或者int y[][]

二维数组实际上是由多个一维数组组成的,他的各个一维数组长度可相同可不同