第一章 数组概述
1. 数组是多个相同类型数据的组合
2. 数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型
3. 数组属引用类型,数组中的每个元素相当于该对象的成员变量
4. 数组中的数据是有序的,可以通过序号(索引或者下标)获取,索引从0开始
第二章 一维数组
第1节 声明和初始化
声明方式: type[] var; type var[]; 中括号表示的是声明一个数组,type表示的是数组中存储数据的类型
举例: int[] arr; int arr[];String[] strs; String strs[];
注意: 类型可以基本类型也可以是引用类型
1. 动态初始化: 数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3]; //创建数组对象使用new关键字,并且初始化数组长度
arr[0] = 3; //数组是一个集合,里面存储的数据都有索引或者叫做下标
arr[1] = 9; //使用下标给数组赋值
arr[2] = 8; //索引从0开始
2. 静态初始化: 在定义数组的同时就为数组元素分配空间并赋值
int a[] = new int[]{ 3, 9, 8}; //在初始化数组的时候直接赋值,不设置长度
int[] a = {3,9,8};//在初始化数组的时候直接赋值,省略new
3. 数组长度的获取
int arr={1,2,3};
int len = arr.length;
第2节 练习
//求数据元素的最大值
public static void main(String[] args) {
int[] arr={2,12,14,13,15,55,66,22,33};
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]>max){
//交换
max=arr[i];
}
}
System.out.println("最大值为:"+max);
}
//求数据元素的最小值
public static void main(String[] args) {
int[] arr={2,12,14,13,15,55,66,22,33};
int min=arr[0];
for (int i = 1; i < arr.length; i++) {
if(arr[i]<min){
//交换
min=arr[i];
}
}
System.out.println("最小值为:"+min);
}
//求总和和平均值
public static void main(String[] args) {
int[] arr={2,12,14,13,15,55,66,22,33};
int sum=0;//总和
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
System.out.println("总和:"+sum);
System.out.println("平均值:"+sum/arr.length);
}
//数组复制
public static void main(String[] args) {
int[] arr={2,12,14,13,15,55,66,22,33};
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr1[i]=arr[i];
}
for (int i : arr1) {
System.out.println("-->"+i);
}
}
//数组的反转
public static void main(String[] args) {
int[] arr={2,12,14,13,15};
for (int i = 0; i < arr.length / 2; i++) {
int temp=arr[i];
arr[i]=arr[arr.length-1-i];
arr[arr.length-1-i]=temp;
}
//反转后
for (int i : arr) {
System.out.println(i);
}
}
//冒泡排序
public static void main(String[] args) {
int[] arr={3,2,7,10};
for (int i = 0; i < arr.length-1; i++) {
for (int j = 0; j < arr.length-i-1; j++) {
if(arr[j]<arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
//排序后
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//选择排序
public static void main(String[] args) {
int[] arr={3,2,7,10};
for (int i = 0; i < arr.length-1; i++) {
int minIndex=i;//最小值索引
for (int j = i+1; j < arr.length; j++) {
if(arr[minIndex]>arr[j]){
minIndex=j; //交换索引
}
}
int temp=arr[i];
arr[i]=arr[minIndex];
arr[minIndex]=temp;
}
//排序后
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//二分查找
public class TestDemo03 {
public static void main(String[] args) {
int[] arr={2,12,14,18,25};
System.out.println(searchRecursion(arr,25));
}
/**
* @param arr: 被查找的数组
* @param key: 要查找的数据
* @return : 返回查找数据的索引
*/
public static int searchRecursion(int[] arr,int key){
//开始索引
int left = 0;
//结束索引
int right=arr.length-1;
while (left<=right){
int middle=(left+right)/2;
if(key==arr[middle]){
return middle;
}else if(key<arr[middle]){
right = middle-1;
}else if(key>arr[middle]){
left=middle+1;
}
}
return -1;
}
}
第三章 二维数组
第1节 声明和初始化
一维数组中存储的是一维数组 声明的语法 type[][] arr;或者 type[] arr[];(这种方式不常见)
动态初始化
方式一: int[][] arr = new int[3][2];
定义一个arr的二维数组,二维数组中有3个一维数组,每一个一维数组中有2个元素
二维数组中的一维数组 arr[0],arr[1],arr[2],给第一个一维数组的1下标赋值 arr[0][1]=100;
方式二: int[][] arr = new int[3][];
定义一个arr的二维数组,二维数组中有3个一维数组,一维数组的长度自己定义
可以给三个一维数组分别初始化arr[0] = new int[2];arr[1]=new int[3];arr[2]=new int[4];
注意: int[][] arr = new int[][3] //非法
静态初始化
方式一 int[][] arr = {{1,2},{3,4},{5,6,7,8}};
方式二 int[][] arr =new int[][] {{1,2},{3,4},{5,6,7,8}};
注意： 如果静态初始化时,先声明后初始化就会编译错误.
int[][] arr;
arr={{1},{2},{4}};
第2节 练习
//杨辉三角
//1. 第一步
/**
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
*/
public static void main(String[] args) {
int[][] arr=new int[10][10];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
//2. 第二步
/**
* 0
* 0 0
* 0 0 0
* 0 0 0 0
* 0 0 0 0 0
* 0 0 0 0 0 0
* 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0
* 0 0 0 0 0 0 0 0 0 0
*/
public static void main(String[] args) {
int[][] arr=new int[10][10];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <= i; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
//3. 第三步
/**
* 1
* 1 1
* 1 0 1
* 1 0 0 1
* 1 0 0 0 1
* 1 0 0 0 0 1
* 1 0 0 0 0 0 1
* 1 0 0 0 0 0 0 1
* 1 0 0 0 0 0 0 0 1
* 1 0 0 0 0 0 0 0 0 1
*/
public static void main(String[] args) {
int[][] arr=new int[10][10];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <= i; j++) {
if(j==0 || i==j){
arr[i][j]=1;
}
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
//4.第四步
/**
* 1
* 1 1
* 1 2 1
* 1 3 3 1
* 1 4 6 4 1
* 1 5 10 10 5 1
* 1 6 15 20 15 6 1
* 1 7 21 35 35 21 7 1
* 1 8 28 56 70 56 28 8 1
* 1 9 36 84 126 126 84 36 9 1
*/
public static void main(String[] args) {
int[][] arr=new int[10][10];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j <= i; j++) {
if(j==0 || i==j){
arr[i][j]=1;
}else{
arr[i][j]=arr[i-1][j-1]+arr[i-1][j];
}
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
