1 .创建数组，输出并且遍历数组
package com.study.reviewss;
public class ArrayTest001 {
public static void main(String[] args) {
//静态创建数组
int[] a = {1,2,6,3,4};
//数组当中可以存储“基本数据类型”的数据，也可以存储“引用数据类型”的数据。
String s1 = new String("abc");
String s2 = new String("def");
//类型要对上，一定是String
String[] b = {s1,s2};
//输出
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a.length);
//遍历数组
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
//动态创建数组
String[] c = new String[3];
for(String s:c){
System.out.println(c);
}
/*数组在内存方面存储的时候，数组中的元素内存地址(存储的每一个元素都是有规则的挨着排列的)是连续的。内存地址连续。
这是数组存储元素的特点（特色）。数组实际上是一种简单的数据结构。
*/
}
}2.多态在数组中的运用
package com.study.reviewss;
public class ArrayTest004 {
public static void main(String[] args) {
//创建对象
Dog dog = new Dog();
Cat cat = new Cat();
//将她们放进数组
Animal[] animals = {dog,cat};
//遍历数组，向下转型
for (int i = 0; i < animals.length; i++) {
if (animals[i] instanceof Dog) {
Dog d = (Dog)animals[i];
d.move();
}else if (animals[i] instanceof Cat) {
Cat c = (Cat)animals[i];
c.move();
}
}
}
}
abstract class Animal{
//设置为抽象方法
public abstract void move();
}
class Dog extends Animal{
@Override
public void move() {
System.out.println("狗跑起来抓人");
}
}
class Cat extends Animal{
@Override
public void move() {
System.out.println("猫抓老鼠");
}
}
//运行结果
//狗跑起来抓人
//猫抓老鼠3.二维数组的创建与遍历
package com.study.reviewss;
/*
关于二维数组中元素的：读和改。
a[二维数组中的一维数组的下标][一维数组的下标]
a[0][0]：表示第1个一维数组中的第1个元素。
a[3][100]：表示第4个一维数组中的第101个元素。
注意：对于a[3][100]来说，其中 a[3] 是一个整体。[100]是前面a[3]执行结束的结果然后再下标100.
*/
public class ArrayTest002 {
public static void main(String[] args) {
//二维数组的创建与遍历
int[][] a = {{1,2,4},{2,7,4},{2,5,1,8}};
//int[][] b = new int[3][4];
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++) {
System.out.println(a[i][j]);
}
}
}
}4.数组的扩容
package com.study.reviewss;
//java.lang.System包下
public class ArrayTest003 {
public static void main(String[] args) {
/*
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
*/
//定义两个数组
int[] arr = {1,4,7,2,9};
int[] desc = new int[10];
//调用方法
System.arraycopy(arr,0,desc,0,5);
//遍历数组
for (int i = 0; i < desc.length; i++) {
System.out.println(desc[i]);
}
}
}5.两种查找指定元素的办法
第一种是傻瓜式查找，相当于遍历数组去查找
第二种是二分查找，我们讲这种，其实Java已经帮我们写好了方法，直接调用即可
使用以下SUN公司提供的数组工具类：java.util.Arrays
|
|
关于查找算法中的：二分法查找。他一定是已经排序好的数组
10(下标0) 11 12 13 14 15 16 17 18 19 20(下标10) arr数组。通过二分法查找，找出18这个元素的下标：
(0 + 10) / 2 --> 中间元素的下标： 5拿着中间这个元素和目标要查找的元素进行对比：
中间元素是：arr[5] --> 15
15 < 18(被查找的元素)
被查找的元素18在目前中间元素15的右边。
所以开始元素的下标从0变成 5 + 1.再重新计算一个中间元素的下标：
开始下标是：5 + 1
结束下标是：10
(6 + 10) / 2 --> 88下标对应的元素arr[8]是18
找到的中间元素正好和被找的的元素18相等，表示找到了：下标为8
|
|
package com.study.reviewss;
import java.util.Arrays;
//static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
// 使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
public class ArrayTest005 {
public static void main(String[] args) {
int[] arr = {1,7,4,2,9};
//key的值是数组中的元素
//将返回的下标用index接收
int index = Arrays.binarySearch(arr,4);
//输出下标
System.out.println(index);
}
}6.数组的几种排序算法
6.1.调用Java lang包下的Arrays sort方法
package com.study.reviewss;
import java.util.Arrays;
public class ArrayTest006 {
public static void main(String[] args) {
int[] arr = {4,7,23,88,11,6};
//调用sort方法
Arrays.sort(arr);
//遍历输出
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}6.2.选择排序
思路
每一次从这堆“参与比较的数据当中”找出最小值，
拿着这个最小值和“参与比较的这堆最前面的元素”交换位置。选择排序比冒泡排序好在：每一次的交换位置都是有意义的。
关键点：选择排序中的关键在于，你怎么找出一堆数据中最小的。
3 2 6 1 5
假设：
第一个3是最小的。
3和2比较，发现2更小，所以此时最小的是2.继续拿着2往下比对，2和6比较，2仍然是最小的。
继续拿着2往下比对，2和1比对，发现1更小，所以此时最小的是1.
继续拿着1往下比对，1和5比对，发现1还是小的，所以1就是最小的。拿着1和最左边的3交换位置。
2 6 3 5
package com.study.reviewss;
//选择排序
public class ArrayTest008 {
public static void main(String[] args) {
int[] arr = {9, 8, 10, 7, 6, 0, 11};
for (int i = 0; i < arr.length-1; i++) {
//先把9定义为最小
int min = arr[i];
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < min) {
min = arr[j];
}
//将最小值与当前下标i 进行交换
if (arr[i] != min) {
int temp = arr[i];
arr[i] = min;
arr[j] = temp;
}
}
}
//遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}6.3冒泡排序
冒泡排序算法
1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
2、核心：
拿着左边的数字和右边的数字比对，当左边 > 右边的时候，交换位置。原始数据：
3, 2, 7, 6, 8
第1次循环：(最大的跑到最右边。)
2, 3, 7, 6, 8 （3和2比较，2 < 3，所以2和3交换位置）
2, 3, 7, 6, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）
2, 3, 6, 7, 8 （7和6交换位置）
2, 3, 6, 7, 8 （虽然不需要交换位置：但是3和7还是需要比较一次。）经过第1次循环，此时剩下参与比较的数据：2, 3, 6, 7
第2次循环：
2, 3, 6, 7 (2和3比较，不需要交换位置)
2, 3, 6, 7 （3和6比较，不需要交换位置）
2, 3, 6, 7 (6和7比较，不需要交换位置)经过第2次循环，此时剩下参与比较的数据：2, 3, 6
第3次循环：
2, 3, 6 (2和3比较，不需要交换位置)
2, 3, 6 （3和6比较，不需要交换位置）经过第3次循环，此时剩下参与比较的数据：2, 3
第4次循环：
2, 3 (2和3比较，不需要交换位置)
package com.study.reviewss;
public class ArrayTest007 {
public static void main(String[] args) {
//静态定义数组
int[] arr = {9, 8, 10, 7, 6, 0, 11};
//外层用来判断比较次数
for (int i = arr.length-1; i > 0; i--) {
//内层用来交换数字
for (int j = 0; j < 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.println(arr[i]);
}
}
}最后附上四张图片加深理解
关于更多排序例如插入，希尔，快速排序可以看看算法与数据结构哪一章
7.作业 单独章节
