Collection集合，数组

------- android培训、java培训、期待与您交流！ ----------

1,定义：集合和数组也是一个引用类型类，不过是用来存储对象的容器（实质存储的是对象的引用地址），方便批量操作引用类型的对象;

2集合与数组的区别：

         2.1储存元素类型:

2.11 数组既可以存储基本数据类型；也可以存储引用类型；但是只能存贮同一种类型的元素；

2.12集合只能是引用类型,所以针对基本类型时；需要用到包装类型；可以存储不同元素类型，通常我们结合泛型使用存储同一种元素类型；

         2.2长度区别

                   2.21数组在初始化时必须指定长度，并且长度固定，获取长度的属性是 .length

                   2.22集合长度是可变的，并且长度会自增，获取长度是方法 .size();

3集合的继承体系结构，根据不同数据结构存储类型和使用不同非为有序，无序，元素可重复，不可重复

Collection（interface）父类api

添加功能

         Boolean  add(E e)

   Boolean  addAll(Collection   c);

删除功能

         Void Clear();

         Boolean   romve(E e)

         Boolean    romveAll(Collection  c);

判断功能

         Boolean    contains(E e);

         Boolean    containsAll(Collection   c);

         Boolean     isEmpty();

获取功能

         迭代器： Iterator<E>  iterator();

         普通for，while循环

         转换到数组toArray();使用循环遍历

长度功能

Int size();

List（interface）元素可重复，有序

ArrayList ：数组数据结构存贮元素，增删慢，查询快，线程不安全，效率高

特有方法：增删，获取可以通过角标来得到元素了，和角标有关的方法都属于特有

Vector：数组数据结构存贮元素，增删慢，查询快，线程安全，效率低

特有方法：早期使用的容器，元素使用Elements后缀，迭代器返回的是枚举类型的，不常用

LinkedList：链表结构，增删快，查询慢，线程不安全，效率高

特有方法：由于底层是链表结构的数据类型

addFirst()

addLast()

removeFirst()

removeLast()

getFirst()

getLast()

练习：模仿堆栈，遍历集合，以及迭代器使用的注意事项；代码演示：

/**

    * 1题目：去除集合中的多个字符串的重复元素2分析：遍历这个形参集合，创建一个新的集合，存入新集合时候，判断3注意：当元素为自定义对象时，必须要重写hashcode（）方法来判断

   public static ArrayList<String>delSame(ArrayList<String> array){

      //1

      ArrayList<String>noSame =newArrayList<String>();

      //2 使用增强for是要判断是否null

      if(!array.isEmpty()){

         for (String string : array){

            //3判断新集合中是否有这个元素

            if(!noSame.contains(string)){

                noSame.add(string);  } } }

      return noSame;  }

   //遍历集合的方式

   public static void forEach(ArrayList<String>arr) {

      //方式一

      if (!arr.isEmpty()) {

         for (String string : arr) {

            System.out.println(string);} }

      //方式二

      for (int i = 0; i <arr.size(); i++) {

         System.out.println(arr.get(i));}

      //方式三

      Iterator<String>it=arr.listIterator();

      while(it.hasNext()){

         //注意：迭代器在使用是不能用容器引用来添加，修改元素，否则会有

         //java.util.ConcurrentModificationException,要用特有的迭代器的方法来操作元素

         System.out.println(it.next());}

      //方式四，其实就是方式三的变形，好处是节省内存

      for (Iterator<String>itFor=arr.listIterator();itFor.hasNext();) {

         System.out.println(itFor.next());}}}

//队列，先进先出

class Myqueue{

   LinkedList<String>link=newLinkedList<String>();

   //进队

   public  void add(String str){

      link.addFirst(str);}

   //出队

   public String get(){

      return link.getLast(); }}

Set（interface）元素不可重复，无序

原理：底层所依赖的都是equals()方法和hashcode()方法来判断元素是否相等的,所以如果要使用Set接口的子类时，自定义类必须要重写这两个方法

HashSet

         存储数据元素的类型为哈希表，无序

TreeSet

         存储数据元素的类型二叉树，有两种排序方案

         1:元素具备比较性：实现Comparable接口，覆盖comparTo()方法让

         2:集合具备比较性：让集合构造方法接收Comparator的实现类对象

注意：因为功能不同，所以实现的接口也不同；

3比较的算法：比较的是哈希值的大小，有1（大），0（相等），-1（小）三个返回值来判断

练习：

1键盘录入学生，按照分数，从高到低进行排序；

分析：排序，使用TreeSet，比较的是分数，所以比较方法中用分数来比较

/**

 * 键盘录入学生按照总分从高到底输出

 * 分析：需要排序的是分数

 */

public classSetDemo {

   public static void main(String[] args) throws NumberFormatException,IOException {

      TreeSet<Student>tree=newTreeSet<Student> (new StudentCompar());

      BufferedReaderbufr = newBufferedReader(newInputStreamReader(System.in));

      System.out.println("请输入姓名，成绩,例如：“张三：56.0”");

      Stringline=null;

      while(true){

         line=bufr.readLine();

         if(line.equals("886") || "".equals(line))

            break;

         //获取构造参数

         String[]stringArr=line.split(":");

         tree.add(new Student(stringArr[0],Float.parseFloat(stringArr[1]))); }

          bufr.close();

      System.out.println(tree.toString()); }

}

//比较器

class StudentCompar implements Comparator<Student>{

   @Override

   public int compare(Student s1,Student s2) {

      return newFloat((s2).getGrades()).compareTo(new Float(s1.getGrades()));

   }

}

数组

特点：元素内容类型一致，通过length属性可以获得元素的个数，其中元素是从角标0开始编号的，所以

角标+1=length

在初始化试必须指定长度，二维数组是数组中存放的是一维数组的引用，定义的格式为：

String[] strArr=new String[4];

Int [][] erWei=new int[3][8];第一个是二维数组的长度，第二个参数是一维数组的长度；

数组代码练习：

//冒泡排序

   public static void boBoSort(int[] arr){

      //两两比较，操作两个元素，但都是内循环在操作，for嵌套

      int temp=0;

      for (int i = 0; i < arr.length-1; i++) {

         for (int j = 0; j < arr.length-i-1; j++) {

            //两两比较

            if(arr[j]>arr[j+1]){

                temp=arr[j];

                arr[j]=arr[j+1];

                arr[j+1]=temp;}}}}

   //选择排序

   public static void choiceSort(int[] arr){

   //思想，数组中的第一个元素和另外一个元素一次判断比较

      //一个区间，两个角标，for嵌套

      int temp=0;

      for (int i = 0; i < arr.length-1; i++) {

         for (int j = i+1; j < arr.length; j++) {

            //判断

            if(arr[i]>arr[j]){

                temp=arr[i];

                arr[i]=arr[j];

                arr[j]=temp;}}}}

//普通查找元素在数组中的位置

public staticint  serach(int[] arr,int key){

      int jiaoBiao=-1;

      for (int i = 0; i < arr.length; i++) {

         if(arr[i]==key){

            jiaoBiao=i;  }}

      return jiaoBiao; }

二维数组的循环功能：

public staticvoiderWeiShow(int[][] arr) {

      int [][] arr=new int[4][6];

      for (int i = 0; i < arr.length; i++) {

         for (int j = 0; j < arr[i].length; j++) {

            System.out.println(arr[i][j]); }}}

总结：

1集合和数组都是单列存储，在使用的时候应该根据自己的需求来定，是有序无序，长度可变还是不可变，以及线程安全还是不安全等等，注意的一点是在使用Collection集合遍历时，在遍历的过程中不能在通过集合的引用来操作集合的元素，否则不安全，因为Iterator这个借口是内部类实现的额，所以，维护要遍历的元素内容时不同时，不安全；

2还有set集合的依据是元素的哈希值和equals方法来判断元素是否相等，所以自定义类型要重写这两个方法。

3比较器的使用有两种方式，因为功能不同所以实现的接口名称也不同，但是比较的方法内容都是一致的。