课前小例
数据类型：
1.基本数据类型：byte short int long float double char boolean
2.引用数据类型：类（String，Scanner等都是类）、接口、数组
数组：它能保存一组数据类型相同的数据。我们把数组保存的数据称之为元素。
声明、创建一个数组：
数据类型 数组变量名称[] = new 数据类型[元素个数]
数组是定长的，在程序运行时，无法改变数组的长度。
int arr[] =new int [8];// arr数组中存在8个元素（数组长度是8）
数组元素的访问--通过索引值（下标值，从0开始到n-1结束）
数组有默认值(整型默认值0，浮点型0.0，字符型\u0000，布尔型false,字符串null)，长度必须指定，new关键字。
arr[0] = 1;// 为数组的第一个元素赋值
数组变量名称在栈中存的是地址，堆中存放着该地址的引用，存储元素、下标、地址。声明的数组名称实际就是栈内存中的地址（16进制）
一维数组：
package com.zpwd.chapter4_0304;
public class ArrayDemo3 {
public static void main(String[] args) {
// 二维数组：数组中含有数组。
int arr[] = { 1, 2, 3 , 4, 5, 6 , 7, 8, 9 ,10};
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
声明、创建数组的三种方式：
第一种：
int arr[] = { 1, 2, 3 , 4, 5, 6 , 7, 8, 9 ,10};
第二种：
int arr[] = new int[10];
arr[0] =1;
...
arr[10]=10;
第三种：
int arr[] = new int[]{ 1, 2, 3 , 4, 5, 6 , 7, 8, 9 ,10};
一维数组内存模型
二维数组内存模型
二维数组：数组中含有数组。
package com.zpwd.chapter4_0304;
public class ArrayDemo3 {
public static void main(String[] args) {
// 二维数组：数组中含有数组。
int arr[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } ,{10},{1,5,7,9,11,33,59}};
for(int i=0;i<arr.length;i++) {
for(int j=0;j<arr[i].length;j++) {
System.out.println(arr[i][j]);
}
}
}
}
冒泡排序（升序）
package com.zpwd.chapter4_0305;
public class Practice2 {
public static void main(String[] args) {
// 冒泡排序(升序)
int num[] = { 8, 5, 6, 2, 3, 7, 9, 1, 4 };
for (int i = 1; i < num.length; i++) {// i为轮次
for (int j = 0; j < num.length - i; j++) {// j为每轮比较时的元素角标
if (num[j] > num[j + 1]) {
int temp;
temp = num[j + 1];
num[j + 1] = num[j];
num[j] = temp;
}
}
}
for(int a:num) {
System.out.print(a+" ");
}
}
}
冒泡排序原理：从数组的一端开始（默认从头开始），每相邻的两个元素比较大小，按照规则（由小到大、由大到小），（默认升序）将两个元素中大的元素放在后面。第一轮比较过后，最大的元素会换到数组的最末端。
（1）通过观察得出：数组中存在n个元素时，需要经过n-1轮比较，才能完成排序。
（2）通过观察得出：每轮比较时，相邻的元素需要比较n-i次。（i为轮次）
选择排序（升序）
package com.zpwd.chapter4_0305;
public class Practice3 {
public static void main(String[] args) {
// 选择排序
int num[] = { 8, 5, 6, 2, 3, 7, 9, 1, 4 };
for (int i = 0; i < num.length-1; i++) {// i为第一个元素
for (int j = i+1; j < num.length; j++) {
if (num[i] > num[j]) {
int temp;
temp = num[j];
num[j] = num[i];
num[i] = temp;
}
}
}
for (int a : num) {
System.out.print(a + " ");
}
}
}
选择排序原理（升序）：从数组中的第一个元素开始，用第一个元素分别与其它位置的元素比较大小，第一个元素存放比较后的最小值。下一轮从数组中的第二个元素开始，用第二个元素分别与其它位置的元素比较大小，第二个元素存放比较后的最小值。以此类推
冒泡排序原理：从数组的一端开始（默认从头开始），每相邻的两个元素比较大小，按照规则（由小到大、由大到小），（默认升序）将两个元素中大的元素放在后面。第一轮比较过后，最大的元素会换到数组的最末端。
面试题
public class HomeWork5 {
public static void main(String[] args) {
// 在一个有8个整数（18,25,7,36,13,2,89,63）
// 的数组中找出其中最大的数及其下标
// 解题思路 ：
int arr[] = {18,25,7,36,13,2,89,63};
// 假设arr[0]是最大值
int max = arr[0];
// 最大值的下标0
int index = 0;
int i = 0;
for(int num : arr) {
if(num > max) {
max = num;
index = i;
}
i++;
}
System.out.println(index+","+max);
// for(int i = 0;i < arr.length;i++) {
// if(arr[i] > max) {
// max = arr[i];
// index = i;
// }
// }
// System.out.println(index+","+max);
}
}
public class Practice3 {
public static void main(String[] args) {
// 模拟35选7 ：生成7个不同的1-35之间的数字（只有一个循环，只涉及一个数组）
boolean b[] = new boolean[35];// 35个false
Random ran = new Random();
for(int i = 0;i < 7;i++) {
// 生成一个1-35之间的数字
int num = ran.nextInt(35)+1;
// 判断之前是否生成过，到b这个数组中检查下标值为num-1对应元素是true还是false来确认是否生成过
if(b[num-1]) {
i--;
}
else {
// 表示生成过
b[num-1] = true;
System.out.print(num+" ");
}
}
}
}
快速排序和数组拷贝
public class Demo3 {
public static void main(String[] args) {
// 快速排序
// int arr[] = {12,1,55,7,89,32};
// Arrays.sort(arr);
// for(int num : arr) {
// System.out.print(num+" ");
// }
// 数组复制
int arr1[] = {1,2,3,4,5};
int arr2[] = {6,7,8,9,10,11,12,13,14,15};
System.arraycopy(arr1, 0, arr2, 4, 2);
for(int num : arr2) {
System.out.print(num+" ");
}
}
}
