1.了解java中的数组？
定义：
数组是指一组数据的集合，数组中的每个数据称为元素。在Java中，数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引用类型),但同一个数组里只能存放类型相同的元素。
创建数组大致包括如下步骤：
1.声明一个数组类型的引用变量，简称为数组变量；
2.用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值；
3.初始化，即为数组的每个元素设置合适的初始值。
数组分为一维数组和多维数组。数组创建方式有三种方式，以一维数组为例。
第一种：通过new对象的方式定义数组，常见的一种方式
int array[]=new int[4];
第二种：通过枚举方式进行初始化数组
int array1[]={0,1,2,3};
第三种：用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值
int array2[]=new int[]{0,1,2,3};
注意：
数组的下标是从0开始的，并且长度不可变，同时注意数组下标越界的异常。另外整数初始的默认值是0。
方法执行顺序：静态代码块>同步代码块>无参构造方法
具体例子如下
执行结果如下：
第一部分数组的基本操作
// 定义一个数组
private long array[];
// 有效的元素个数
private int elements;
static {
System.out.println("静态代码块");
}
{
System.out.println("同步代码块");
}
public MyArray() {
array = new long[50];
System.out.println("无参构造方法");
}
public MyArray(int maxsize) {
array = new long[maxsize];
System.out.println("有参构造方法");
}
// 定义添加数组数据的方法
public void insert(long value) {
// 整数的初始默认值是0
System.out.println(elements);
array[elements] = value;
elements++;
}
// 遍历数组的元素
public void dispaly() {
System.out.print("[");
for (int i = 0; i < elements; i++) {
System.out.print(array[i] + " ");
}
System.out.println("]");
}
// 根据值查找，查找数组中的元素（如果数组中有重复元素，只能查找到第一个）
public void serach(long value) {
int i;
for (i = 0; i < elements; i++) {
if (array[i] == value) {
System.out.println("array"+"["+i+"]"+"="+ array[i]);
break;
}
}
if (i == elements) {
System.out.println("找不到相应元素");
}
}
// 根据索引，查找数组中的元素
public void getSerach(int index) {
if (index >= elements || index < 0) {
throw new ArrayIndexOutOfBoundsException();
} else {
System.out.println(array[index]);
}
}
// 根据索引删除元素(后一个元素覆盖前一个元素)
public void delete(int index) {
if (index >= elements || index < 0) {
throw new ArrayIndexOutOfBoundsException();
} else {
for (int i = index; i < elements; i++) {
array[index] = array[index + 1];
}
elements--;
}
}
// 根据索引更新数组中的元素
public void update(int index,int newvalue) {
if (index >= elements || index < 0) {
throw new ArrayIndexOutOfBoundsException();
} else {
array[index]=newvalue;
System.out.println("array"+"["+index+"]"+"="+array[index]);
}
}
测试部分：
数组从小到大排列 和二分法查找元素
public static int array[] = { 17, 31, 17, 23, 26, 69, 0, 34, 15, 27 };
public static void main(String[] args) {
paixun();
System.out.println(binarySerach(23));
}
//数组元素从小到大排序
public static void paixun() {
int max = 0;
int tmp = 0;
for (int i = 0; i < array.length; i++) {
max = i;//
/** 查找第 i大的数，直到记下第 i大数的位置 ***/
for (int j = i + 1; j < array.length; j++) {
if (array[max] > array[j])
max = j;// 记下较大数位置，再次比较，直到最大
}
/*** 如果第 i大数的位置不在 i,则交换 ****/
if (i != max) {
tmp = array[i];
array[i] = array[max];
array[max] = tmp;
}
}
for (int i = 0; i < array.length; i++)
System.out.print(array[i] + " ");
}
// 根据二分法查找数组中的元素
public static int binarySerach(int value) {
// 中间元素的索引
int middle = 0;
// 最小元素索引
int min = 0;
// 最大元素索引
int max = array.length - 1;
while (true) {
middle = (max + min) / 2;
if (array[middle] == value) {
return middle;
// 判断是否从小到大按顺序排列
} else if (min > max) {
return -1;
} else {
// 判断是在中间元素的位置（左或者右）
if (array[middle] > value) {
max = middle - 1;
} else {
min = middle + 1;
}
}
}
}
}
完整版：
public class Test {
// 定义一个数组
private int array[] = new int[6];
// 元素个数
private int elements;
public static void main(String[] args) {
Test test = new Test();
// 数组中添加数据
test.insert(12);
test.insert(17);
test.insert(32);
test.insert(62);
test.insert(43);
test.insert(25);
// 遍历数组中元素
test.display();
// 根据值查找数组中的元素
test.serach(43);
// 根据索引查找数组中的元素
test.getSerach(2);
// 从小到大排序
test.sort();
// 二分法查找元素
test.binarySerach(12);
// 遍历数组中元素
test.display();
// 根据索引，删除数组中的元素（后一个覆盖前一个）
test.delete(1);
// 遍历数组中元素
test.display();
}
// 添加数组中的元素（初始化数组）
public void insert(int value) {
array[elements] = value;
elements++;
}
// 遍历数组元素
public void display() {
System.out.print("[");
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
System.out.println("]");
}
// 根据值查找数组中的元素
public void serach(int value) {
int i;
for (i = 0; i < array.length; i++) {
if (array[i] == value) {
System.out.println("array[" + i + "]" + "=" + array[i]);
break;
}
}
if (i >= array.length) {
System.out.println("数组中该元素不存在");
}
}
// 根据索引查找数组中的元素
public void getSerach(int index) {
if (index > array.length || index < 0) {
System.out.println("输入的下标不合理");
} else {
System.out.println("索引方式1：" + array[index]);
}
for (int i = 0; i < array.length; i++) {
if (i == index) {
System.out.println("索引方式2：" + array[index]);
break;
}
}
}
// 根据索引，删除数组中的元素（后一个覆盖前一个）
public void delete(int index) {
if (index >= array.length || index < 0) {
System.out.println("输入的下标不合理");
} else {
for (int i = index; i < array.length - 1; i++) {
array[i] = array[i + 1];
}
// 最后一个元素补0
array[array.length - 1] = 0;
}
}
// 从小到大排序，选择排序
public void sort() {
int min = 0;
int temp = 0;
for (int i = 0; i < array.length; i++) {
// 初始化最小索引
min = i;
for (int j = i + 1; j < array.length; j++) {
// 判断从第一个元素是否是第一最小的，第二个元素是否是第二最小的，依次类推......不是最小的时候交换
if (array[min] > array[j]) {
temp = array[min];
array[min] = array[j];
array[j] = temp;
}
}
}
}
// 二分法查找元素
public int binarySerach(int value) {
// 中间索引
int middle = 0;
// 最小索引
int min = 0;
// 最大索引
int max = array.length - 1;
while (true) {
middle = (max + min) / 2;
// 先判断中间元素是否等于查找元素
if (array[middle] == value) {
System.out.println("元素下标是：" + middle);
return middle;
} else if (min > max) {
System.out.println("没有查到相应元素");
return -1;
} else {
// 再判断是向左还是向右，大于中间元素，最小的索引等于中间索引加1
if (array[middle] < value) {
min = middle + 1;
}
// 小于中间元素，最大的索引等于中间索引减1
if (array[middle] > value) {
max = middle - 1;
}
}
}
}
}
运行结果：
总结：
本人数据结构小白一个，上面所述如有更好的方法，请赐教，学数据结构自己就要多想多练，不断去总结，欢迎志同道合者一起学习。