内容
1.一维数组
2.一维数组和多态综合使用
3.数组作为参数的传递方式
4.拷贝数组
5.二维数组
6.选择排序和冒泡排序
7.二分法查找
数组是一种引用类型
Java的数组和c/c++有很多相通之处
一.一维数组
1.静态初始化一维数组
类型 [] 名称 = {元素};
比如
int[] a1 = {1,2,3};
2.小知识
①a1.length
就是元素个数，这里是length属性，不是length方法
3.动态初始化一维数组
比如
int[] a1 = new int[4];
注意：动态初始化一维数组，会先在堆内存中分配这个数组，并且数组中每一个元素都采用默认值。
2.小知识（续）
②如果o是一个空指针（空引用）
那么
System.out.println(o);
System.out.println(o.toString());
下面那一行会报空指针异常错误，而上面的输出null。
③初始化的时候是c++的形式也可以，但是不建议写成c++形式
二.一维数组和多态综合使用示例
public class 测试程序 {
public static void main(String[] args){
//动态初始化一维数组
Animal[] Ani = new Animal[4];
//分别创建两个狗对象和两个猫对象
Dog d1 = new Dog();
Dog d2 = new Dog();
Cat c1 = new Cat();
Cat c2 = new Cat();
//给数组中的每个元素赋值
Ani[0] = d1;
Ani[1] = d2;
Ani[2] = c1;
Ani[3] = c2;
//需求：遍历数组，取出每个对象，如果是Dog就执行Eat方法，如果是Cat就执行Move方法
for(int i = 0;i < Ani.length;i++) {
//先转换到父类
Animal temp = Ani[i];
//调用toString方法
System.out.println(temp);
//强制类型转换（向下转型）
if(temp instanceof Dog) {
Dog dog = (Dog)temp;
dog.Eat();
}else if(temp instanceof Cat) {
Cat cat = (Cat) temp;
cat.Move();
}
}
}
}
//定义一个动物类
class Animal{
}
//定义一个狗类,继承动物类
class Dog extends Animal{
//吃方法
public void Eat() {
System.out.println("Dog eat!!!");
}
}
//定义一个猫类，继承动物类
class Cat extends Animal{
//移动方法
public void Move(){
System.out.println("Cat move!!!");
}
}
输出结果为：
对象.Dog@15db9742
Dog eat!!!
对象.Dog@6d06d69c
Dog eat!!!
对象.Cat@7852e922
Cat move!!!
对象.Cat@4e25154f
Cat move!!!
三.数组作为参数的传递方式
代码示例
public class 测试程序 {
public static void main(String[] args){
int[] a = {1,2,3};
//传递数组参数的第一种方式
Arraywatch(a);
//传递数组参数的第二种方式
Arraywatch(new int[] {4,5,6});
//主要是这种方式没见过
}
//遍历数组的一个方法
public static void Arraywatch(int[] a) {//注意这里要把方法定义为静态的
for(int i = 0;i < a.length;i++) {
//输出数组每个元素
System.out.println(a[i]);
}
}
}
四.拷贝数组
1.语法
System.arraycopy(源数组，源数组下标，目标数组，目标数组下标，元素个数);
2.使用示例
public class 测试程序 {
public static void main(String[] args){
//定义源数组
int[] src = {1,2,3,4,5};
//定义目标数组
int[] dest = {10,11,12,13,14,15,16,17};
//要求把源数组2 3 4拷贝到目标数组的13 14 15
System.arraycopy(src, 1, dest, 3, 3);
//遍历目标数组
for(int i = 0;i < dest.length;i++) {
System.out.println(dest[i]);
}
}
}
五.二维数组
1.静态初始化二维数组
示例：
int[][] a = {
{},
{},
{}
};
2.动态初始化二维数组
示例
int[][]b = new int[3][4];
六.选择排序和冒泡排序
由于冒泡排序在c语言博客已经写过，这里就不再赘述
选择排序
知识点全在代码里面
public class 测试程序 {
public static void main(String[] args){
//定义数组
int[] a = {3,1,6,2,5};
//选择排序
//是经过每一次循环，选出最小的，把最小的放在最左边
//先模拟执行过程
/*
* ①1 3 6 2 5
* ②1 2 6 3 5
* ③1 2 3 6 5
* ④1 2 3 5 6
* 总共执行四次，
* 第一次是从第一个开始找，即下标是0
* 2 1
* 3 2
* 4 3
*/
//选择排序
for(int i = 0;i < a.length - 1;i++) {//执行了四次，所以是元素个数-1
//先假定每一轮最开始的那个元素是最小的
//赋值最小值下标
int min = i;
for(int j = i+1;j < a.length;j++){//注意这里是i+1而不是j=i
//如果有比a[min]更小的数，则把min重新赋值
if(a[min] > a[j]) {
//注意，这里和冒泡排序就不一样了，不先交换位置，而是把min重新赋值
/*int temp = a[min];
a[min] = a[j];
a[j] = temp;*/
min = j;
}
}
//如果不是最开始那个min了，说明上面那个if条件曾经成立过，然后就把每一轮最开始的数换成最小的
//考虑互换
if(min != i) {
int temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
//输出这个数组
for(int i = 0;i < a.length;i++) {
System.out.println(a[i]);
}
}
}
七.二分法查找
注意：二分法查找是建立在已经排序的数组的基础之上的
知识点全在代码里面
public class 测试程序 {
public static void main(String[] args){
//1,2,3,9,11,13,56共七个元素
//找13，即下标是5
/* int begin = 0;
* int end = 6;
* int mid = (0+6）/2 = 3
* 下标是3的这个元素值小于13，所以13在它的右边
* 所以begin = mid + 1 = 4;
* mid = (4+6)/2 = 5
* 5对应的元素正好是13
* 这就是二分法查找
*/
//定义一个已经排好序的数组
int [] a = {1,3,4,5,7,8,9,10,23,25,29};
//定义并初始化目标元素，比如我要找29这个元素的下标
int destElement = 29;
//使用方法查找，如果找不到这个元素，就返回-1
int index = binarySearch(a,destElement);
//输出目标元素的下标
System.out.println(index);
}
//定义二分法查找数组元素的方法
public static int binarySearch(int[] a,int destElement) {
//先定义开始和结束位置
int begin = 0;
int end = a.length - 1;
//使用while循环
while(begin <= end) {//注意这里是<=而不是<
//每一次循环都需要求出中间下标
int mid = (begin + end)/2;
if(a[mid] == destElement) {
return mid;
}else if(a[mid] > destElement) {//目标元素在中间元素的左边
end = mid - 1;
}else if(a[mid] < destElement) {//目标元素在中间元素的右边
begin = mid + 1;
}
}
//如果没找到，就返回-1
return -1;
}
}
