1.JDK、JRE、JVM
JDK=JRE+开发工具集（如：javac编译工具等）
JRE=JVM+javaSE标准类库
image
2.数据的存储结构
（一对一）线性表：顺序表（如：数组）、链表、栈、队列
（一对多）树形结构：二叉树
（多对多）图形结构：
基本算法：排序和搜索
3.数组
数组特点：1.有序；2.数组本身是引用数据类型变量，但数组的元素既可以是引用数据类型，也可以是基本数据类型；3.数组会开辟一整块连续空间（链表就不连续）；4.数组长度一旦确定，就不能修改
一维数组定义：
//动态初始化：数组初始化和赋值分开进行
int[] arr = new int[4];
//静态初始化：数组初始化和赋值操作同时进行
int[] arr01 = new int[]{1,2};
数组的默认初始化值
整型：0 浮点型：0.0 char型：0或’\u0000‘，不是‘0’ boolean:false 引用数据类型：null
内存结构：
image
一维数组内存结构
image
二维数组：
//动态初始化
int[][] arr02 = new int[3][2];
int[][] arr03 = new int[3][];
int[] arr04[] = new int[2][4];
//静态初始化
int[][] arr05 = new int[][]{{1,2},{2,4},{5,6}};
//类型推断
int[][] arr06 = {{1,2},{2,4},{5,6}};
/*
* 二维数组默认初始化值：
* 外层元素：地址值
* 内层元素：与定义数组类型的一维数组默认初始化值一样
* */
int[][] arr07 = new int[3][4];
System.out.println(arr07);//[[I@15db9742
System.out.println(arr07[0]);//[I@6d06d69c
System.out.println(arr07[0][0]);//0
int[][] arr08 = new int[3][];
System.out.println(arr08);//[[I@7852e922
System.out.println(arr08[0]);//null
System.out.println(arr08[0][0]);//报错
二维数组内存解析
图片.png
数组简单算法：
1.算法考察： 求数值型数组中元素的最大值、最小值、平均数、总和等
/*
*定义一个int型一维数组，包含10个元素，分别赋一些随机整数；
*求出所有元素的最大值、最小值、平均数、总和。
*要求：所有随机数都是两位
* * */
int[] arr = new int[10];
for(int i = 0;i < arr.length;i++){
arr[i] = (int) (Math.random()*(90)+10); //Math.random()*100有可能返回一位整数
System.out.print(arr[i]+"\t");
}
Sysm.out.println();
/*
* 最大值
* */
int maxValue = arr[0];//若全都是负数，则赋0不对，故定义第一个为maxValue
for(int i = 0;i < arr.length;i++){
if(maxValue < arr[i]){
maxValue = arr[i];
}
}
System.out.println(maxValue);
/*
* 最小值
* */
int minValue = arr[0];//若全都是负数，则赋0不对，故定义第一个为maxValue
for(int i = 0;i < arr.length;i++){
if(minValue > arr[i]){
minValue = arr[i];
}
}
System.out.println(minValue);
/*
* 总数
* */
int sum = 0;//若全都是负数，则赋0不对，故定义第一个为maxValue
for(int i = 0;i < arr.length;i++){
sum += arr[i];
}
System.out.println(sum);
/*
* 平均数
* */
double avg = 0;//若全都是负数，则赋0不对，故定义第一个为maxValue
avg = (sum / arr.length)*0.1;
System.out.println(avg);
2.使用二维数组打印一个10行杨辉三角
/*
* 杨辉三角：
* 1.第一行有1个元素，第n行有n个元素
* 2.每行的开头和末尾都为1
* 3.第3行开始，对于每行的非第1和最后一个元素，a[i][j] = a[i-1][j]+a[i-1][j-1]
* */
int[][] arr = new int[10][];
//给数组元素赋值
for(int i = 0;i < arr.length;i++){
//第一行有1个元素，第n行有n个元素
arr[i] = new int[i+1];
//2.1给首末元素都赋值为1
arr[i][0] = arr[i][i] = 1;
//2.2给非首末元素赋值
if(i > 1){
for(int j = 1; j < arr[i].length-1;j++){
arr[i][j] = arr[i-1][j]+arr[i-1][j-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");
}
System.out.println();
}
使用简单数组
* 使用简单数组
* 1.创建一个名为ArrayTest的类，在main方法中声明array1和array2两个变量，他们是int[]类型的数组
* 2.使用{ }，把array1初始化为8个素数，2,3,5,7,11,13,17,19
* 3.显示array1的内容
* 4.赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值（如array[0]=0,array[2]=2）打印array1
*
* array1和array2的关系，仅仅是公用同一个地址
* */
int[] array1,array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
array2 = new int[8];
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i]+"\t");
}
System.out.println();
//将array1赋值给array2，不能称作数组的复制
array2 = array1;//即仅仅给的是array1的地址
//偶元素索引
for (int i = 0; i < array2.length; i++) {
if(i % 2 == 0){
array2[i] = i;
}
System.out.print(array2[i]+"\t");
}
//打印array1
for(int i = 0;i < array1.length;i++){
System.out.print(array1[i]+"\t");
}
3.数组的复制
//数组的复制。即区别于数组的赋值
for(int i = 0;i < array1.length;i++){
array2[i] = array1[1];
System.out.print(array1[i]+"\t");
}
4.数组的反转
//数组的反转
//方法一
int[] arr = new int[]{2,3,5,7,17,19};
for(int i = 0; i < arr.length / 2 ;i++){
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i]+"\t");
}
System.out.println();
//方法二
int[] arr1 = new int[]{2,3,5,7,11,17,19};
for(int i = 0,j = arr.length-1; i < j ;i++,j--){
int temp = arr[i];
arr[i] = arr[j];
arr[i] = temp;
}
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i]+"\t");
}
5.数组的线性查找
/*
* 数组的线性查找
* */
String[] arr = new String[]{"a","b","c"};
String str = "d";
boolean isFlag = true;
for (int i = 0; i < arr.length; i++) {
if(str.equals(arr[i])){
System.out.println("找到元素位置为："+i);
isFlag = false;//
break;//找到就跳出循环
}
}
if(isFlag){
System.out.println("没找到");
}
6.二分法查找:查找的元素所在对象必须有序排列（速度快）
/*
* 二分法查找
* */
int[] arr = new int[]{-90,-34,-25,2,5,8,10,25,67};
int dest = 2;
int head = 0;//定义头
int end = arr.length - 1;//定义尾
boolean isFlag = true;
while(head <= end){//对最后一个位置也得进行比较
int mid = (head + end) / 2;
if(dest == arr[mid]){
System.out.println("找到元素位置为："+mid);
isFlag = false;
break;
}else if(dest > arr[mid]){
head = mid + 1;
}else{
end = mid - 1;
}
}
if(isFlag){
System.out.println("没找到");
}
7.冒泡排序：依次比较相邻的两个元素，将最大值依次交换到末尾，冒泡完的数组为顺序排序
/*
* 冒泡排序：
* */
int[] arr = new int[]{23,-5,26,-59,-42,5,86,99};
for (int i = 0; i < arr.length - 1; i++) {
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;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+"\t");
}
8.快速排序**
