数组与队列

数组与队列

1、数组

1.1数组基本用法

  数组是java中最基本的一种数据结构，数组可以理解为存储相同类型数据的一种容器，一个数组一旦定义，其长度与类型都已经固定。数组中的每一个值都有固定的索引值。
  使用数组的过程中需要注意的是：数组的长度是固定的，数组是有序的，数组中的每个元素都有一个唯一的索引位置，这个索引值从0开始，最大为数组长度-1；如果数组长度为10，则最后一个元素的索引位置就是9。
  取得数组的长度，可以通过  数组名.length 得到；
  取得数组某一位置的值，可以通过数组名[索引值]得到。
  关于数组需要特别注意的一点，这一点经常使程序报错。就是数组越界，我自己就经常出现数组越界的错误。例子如下

public class Array {
 public static void main(String[] args){
  //定义长度为10的int型数组
  //定义格式为：类型[] 数组变量名=new 类型[长度]
  int[] x=new int [10];
  for(int i=0;i<x.length;i++){
   x[i]=i;
  }
  x[10]=1000;//越界取值出错
 }
}

运行结果如下

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
 at com.smz.arraylist.Array.main(Array.java:11)

大家在运用数组时需要避免该问题的出现。

1.2数组的排序

  排序是一类算法常用的算法实现，而其中最常用的就是冒泡排序和选择排序法了。
冒泡排序法

for (int i = 0; i < x.length; i++) {
    for (int j = i + 1; j < x.length; j++) {
     if (x[i] > x[j]) {
      int temp = x[i];
      x[i] = x[j];
      x[j] = temp;
      }
}

选择排序法

for (int i = 0; i < x.length; i++) {
    int min = i;
    for (int j = i + 1; j < x.length; j++) {
     if (x[j] < x[min]) {
      min = j;
     }
    }
    // 交换
    int temp = x[i];
    x[i] = x[min];
    x[min] = temp;

其实排序的方式还有其他如希尔排序和插入排序，但是冒泡和选择是最基础的两种算法，因此我们在此就提一下这两种算法了。

2.队列

  对于数组来说有一个最大的缺陷就是，用户在输入一组数据时，肯定是不知道要输入多少个数据的，而在程序中，我们用数组保存数据：数组的规则是一但定义，长度就是固定的。
  这就需要我们自己实现一种对象：队列，它可以像数组一样有序的存放对象；但与数组最大的区别就是，它可以自动增长。接下来我们就来学习一下怎么创建一组队列。

2.1队列的需求

  创建一个队列前，我们需要先考虑一下队列能提供的功能有哪些，我们可以参考系统所提供的ArrayList，看一下系统提供的队列方法有哪些。然后选择我们所需要的方法，开始创建，首先我们先定义队列接口。
队列接口如下所示：

public interface Arraylist<E> {
 public void add(E e);//存储数据
 public E get(int index);//获取数据
 public void judge(E e);//判断是否含有某个数据
 public int getsize();//获取列表元素个数
 public void delete(E e);//删除列表元素
 public void rewrite(E e,E x);//修改数据
 public void combine(List<E> a);//合并列表
}

2.2简单实现

根据这些需求编写方法的内容

public class List<E> implements Arraylist<E> {
  Object[] E = new Object[0];
  int Size=E.length;
  public void add(E e) {
    // 存储数据
    Object[] obj = new Object[Size + 1];
    System.arraycopy(E, 0, obj, 0, E.length);
    E=obj ;
    E[Size++] = e;
  }
  public E get(int index) {
    // 获取数据
    E obj = (E) E[index];
    return obj;
  }
  public void judge(E e) {
    // 判断是否含有某个数据
    int n = 0;
    for (int i = 0; i < E.length; i++) {
     if (e.equals(E[i])) {
         System.out.println("yes");
         n = 1;
      }
    }
    if (n == 0) {
      System.out.println("no");
    }
  }
  public int getsize() {
    // 获取列表元素个数
    return E.length;
  }
  public void delete(E e) {
    // 删除列表元素
    int a = 0;
    Object[] obj = new Object[Size];
    for (int i = 0; i < E.length; i++) {
      if (E[i].equals(e)) {
         Size--;
      } else {
         obj[a] =E[i];
         a++; 
      }
    }
    E=obj;
  }
  public void rewrite(E e, E x) {
    // 修改数据
    Object[] obj = new Object[Size];
    for (int i = 0; i < Size; i++) {
      if (e.equals(E[i])) {
         obj[i]= x;
      }
     else{
        obj[i]=E[i];
      }
    }
      E=obj;
  }
  public void combine(List<E> a) {
    Object[] b=new Object[a.E.length+ E.length];
    System.arraycopy(a.E, 0, b, 0, a.E.length);
    System.arraycopy(E, 0, b, a.E.length, E.length);
    E=b;
  }

在上面的队列中，我们需要注意的一点就是，我们为了使放进队列的类多元化，我们使用了<>符号，这个符号的含义是“泛型”他代表了一个类，我们只需要在创建对象的时候定义好这个类就可以方便的进行使用。例如我们要使用一组整型的列表。
使用方法如下：

public static void main(String[] args) {
  List<Integer> list = new List<Integer>();
  List<Integer> list1 = new List<Integer>();
  list.add(56);
  list.add(45);
  list.add(57);
  list.add(12);
  list.add(14);
  list.add(15);
  list.add(15);
  list.add(18);
  list.add(13);
  list.add(15);
  list1=list;
  list.delete(15);
  list.judge(30);
  list.rewrite(14, 90);
  int a = list.getsize();
  list.combine(list1);
  System.out.println(a);
  for (int i = 0; i < list.E.length; i++) {
   System.out.println(list.E[i]);
  }
  for (int i = 0; i < list.E.length; i++) {
   System.out.println(list1.E[i]);
  }

如果我们需要使用其他的类型，只需要在新建类的时候在<>输入你需要的类型。这样就能十分方便的使用自己的队列，对输入的数据进行管理了。