数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名。并通过编号的方式对这些数据进行统一管理。
数组的常见概念：
数组名、下标、元素、数组的长度
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
创建数据对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
数组的长度一旦确定，就不能修改
我们可以直接通过下标（或索引）的方式调用指定位置的元素，速度很开
数组的分类：
一维数组，二维数组，多维数组
基本数据类型元素的数组，引用数据类型元素的数组
数据结构1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2.数据的存储结构：
线性表：顺序表（比如：数据）、链表、栈、队列
树形结构：二叉树
图形结构：图
算法：
排序算法：
搜索算法：
一维数组：
package com.kuang.array;
public class ArrayTest {
public static void main(String[] args) {
//一维数组的声明和初始化
//如何去遍历一个数组元素
//数组元素的默认初始化值
//练习 0 1 2 3 4
int [] arr = new int [] {8,2,1,0,3};
int [] index = new int [] {2,0,3,2,4,0,1,3,2,3,3};
String tel = ""; //0 1 2 3 4 5 6 7 8 9 10
for(int i = 0;i < index.length;i++){
tel +=arr[index[i]];
//tel = tel + arr[index[i]]
// 18013820100
}
System.out.println(tel);
}
}
二维数组：
package com.kuang.array;
import javax.xml.bind.SchemaOutputResolver;
public class ArrayTest2 {
public static void main(String[] args) {
int [] arr = new int []{1,2,3};
int [][] arr1 = new int [][]{{1,23},{4,5,6}};//静态初始化
String [][] arr2 = new String[3][2]; //动态初始化1
String [][] arr3 = new String[3][]; //动态初始化2
//2.如何调用数据的指定位置的元素
System.out.println(arr1[0][1]);
System.out.println(arr2[1][1]);
arr3[1]= new String[4];
System.out.println(arr3[1][0]);
//获取数组的长度
int [] arr4 [] = new int [][]{{1,2,3},{4,5},{6,7,8}};
System.out.println(arr4[0].length);
System.out.println(arr4[1].length);
//如何遍历一个二维数组
for (int i = 0; i < arr4.length; i++) {
for(int j = 0; j
杨辉三角的代码：
package com.kuang.project;
public class YangHuiTest {
public static void main(String[] args) {
//声明并初始化二维数组
int [][] yangHui = new int[10][];
//给数组的元素赋值
for(int i = 0;i1){
for(int j = 1; j< yangHui[i].length - 1;j++){
yangHui[i][j] = yangHui[i-1][j-1]+yangHui[i-1][j];
}
}
}
//遍历二维数组
for(int i = 0;i
数组中涉及的常见算法
1.数组元素的赋值（杨辉三角、回形树）
2.求数值型数组中元素的最大值、最小值、平均数、总和等
3.数组的复制、反转、查找（线性查找、二分法查找）
4.数组元素的排序算法
排序算法
时间复杂度：分析关键字的比较次数和记录的移动次数
空间复杂度：分析排序算法中需要多少辅助内存
稳定性：若两个记录A和B的关键字值相等，但排序后A、B的先后次序保持不变，则称这种排序算法是稳定的。
排序算法的分类：内部排序和外部排序
内部排序：整个排序过程不需要借助于外部存储器（如磁盘等），所有排序操作都在内存中完成的。
外部排序：参与排序的数据非常多，数据量非常大，计算机无法把整个排序过程放在内存中完成，必须借助于外部存储器，外部排序最常见的是多路归并排序，可以认为外部排序是由多次内部排序组成。
十大内部排序算法：
选择排序：直接选择排序、堆排序（了解）交换排序：冒泡排序、快速排序（会手写）插入排序：直接插入排序、折半插入排序、Shell排序（希尔排序）归并排序（了解）桶式排序基数排序
package com.kuang.array;
public class BubbleSortTestt {
public static void main(String[] args) {
int [] arr = new int []{234,34,64,76,345,};
//实行冒泡排序
//for(int i = 0;i
for(int i = 1;i arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] =temp;
}
}
}
for(int i = 0;i
package com.kuang.array;
//快速排序
public class QuickSort {
private static void swap(int[] data,int i ,int j){
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data,int start ,int end){
if(start < end){
int base = data[start];
int low = start ;
int high = end + 1;
while(true){
while(low < end && data[++low] - base <=0)
;
while(high > start && data[--high] - base >= 0)
;
if(low < high){
swap(data,low ,high);
}else{
break;
}
}
swap(data,start,high);
subSort(data,start,high - 1);
subSort(data,high + 1,end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int [] data = {2,4,6,4,-23,4,23,7,0};
quickSort(data);
System.out.print(java.util.Arrays.toString(data));
}
}
package com.kuang.array;
import sun.java2d.pipe.SpanIterator;
public class ArrayTest3 {
public static void main(String[] args) {
int [] []arr = new int [4][3];
System.out.println(arr[0]);//[I@1b6d3586
System.out.println(arr[0][0]);//0
System.out.println(arr);//[[I@4554617c
System.out.println("==============");
float [] []arr1 = new float [4][3];
System.out.println(arr1[0]);//[I@1b6d3586
System.out.println(arr1[0][0]);//0
System.out.println(arr1);//[[I@4554617c
System.out.println("============");
String [] []arr2 = new String [4][3];
System.out.println(arr2[0]);//[I@1b6d3586
System.out.println(arr2[0][0]);//0
System.out.println(arr2);//[[I@4554617c
System.out.println("===========");
double [] []arr3 = new double [4][];
System.out.println(arr3[1]);//[I@1b6bd3586
System.out.println(arr3[0][0]);//报错
System.out.println(arr3);//[[I@4554617c
}
}
package com.kuang.project;
import sun.java2d.pipe.SpanIterator;
public class ArrayDemo04 {
public static void main(String[] args) {
int [] arr = new int[10];
for(int i = 0;i arr[i]){
minValue= arr[i];
}
}
System.out.println("最小值为："+minValue);
//求数组元素的总和
int sum = 0 ;
for(int i = 0 ; i
package com.kuang.project;
public class ArrayDemo05 {
public static void main(String[] args) {
int [] array1,array2;
array1 = new int []{2,3,5,7,11,13,17,19};
for(int i = 0;i
package com.kuang.project;
public class ArrayDemo06 {
public static void main(String[] args) {
int [] array1,array2;
array1 = new int []{2,3,5,7,11,13,17,19};
for(int i = 0;i
package com.kuang.project;
public class ArrayDemo07 {
public static void main(String[] args) {
//遍历
int[] arr2 = new int []{-98,-47,-12,12,34,45,89};
int dest1 = 3400;
boolean isFlag1 = true;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末尾索引
while(head <= end){
int middle = (head +end) / 2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素，位置为："+middle);
isFlag1 = false;
break;
}else if (arr2[middle]>dest1){
end = middle -1;
}else{
head = middle + 1;
}
}
if (isFlag1){
System.out.println("很遗憾，没有找到元素");
}
}
}
package com.kuang.project;
import sun.java2d.pipe.SpanIterator;
public class ArrayDemo08 {
public static void main(String[] args) {
int [] arr = new int [] {34,6,-5,14,-56,41};
System.out.print("原始的数组：");
for(int i = 0;i arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int i = 0 ;i 
