Java基础语法_Day18

一、集合&迭代器
  • 集合体系结构
  • 集合体系图


    集合体系图.png

    在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要学习Collection中共性方法,然后再去针对每个子类集合学习它的特有方法

  • 案例代码一:
package com.neuedu.demo;

import java.util.ArrayList;

/*
*  ArrayList
*  集合的体系结构:
*     由于不同的数据结构(数据的组织,存储方式),所以Java为我们提供了不同的集合,
*     但是不同的集合他们的功能都是相似,不断的向上提取,将共性抽取出来,这就是集合体系结构形成的原因
*  
*  体系结构:
*         怎么学习?最顶层开始学习,因为最顶层包含了所有的共性
*         怎么使用?使用最底层,因为最底层就是具体的实现
*  
*  Collection
*  List
*  ArrayList
*/
public class CollectionDemo {
  public static void main(String[] args) {        
      //创建集合对象
      ArrayList al = new ArrayList();
      //添加元素
      al.add("hello");
      al.add("world");
      al.add("java");
      //遍历集合
      for(int x = 0;x < al.size();x++) {
          System.out.println(al.get(x));
      }
      
  }
}
  • Collection中的常用功能

boolean add(Object e): 向集合中添加元素
void clear():清空集合中所有元素
boolean contains(Object o):判断集合中是否包含某个元素
boolean isEmpty():判断集合中的元素是否为空
boolean remove(Object o):根据元素的内容来删除某个元素
int size():获取集合的长度
Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中

  • 案例代码二:
package com.neuedu.demo
import java.util.ArrayList;
import java.util.Collection;

/*
*     Collection  
*             boolean add(E e)  
*             void clear()  
*             boolean contains(Object o)  
*             boolean isEmpty() 
*             boolean remove(Object o) 
*             int size() 
*             Object[] toArray() 
*             Iterator<E> iterator()  
*         
*/
public class CollectionDemo2 {
  public static void main(String[] args) {        
      //创建集合对象
      //Collection c = new Collection();//Collection是接口,不能实例化
      Collection c = new ArrayList();//多态,父类引用指向子类对象  
      
      //boolean add(E e)  
      System.out.println(c.add("hello"));//永远可以添加成功,因为ArrayList他允许重复
      System.out.println(c.add("world"));
      
      //void clear():清空集合
      //c.clear();
      
      //boolean contains(Object o)  :判断集合中是否包含指定元素
      //System.out.println(c.contains("java"));
      
      //boolean isEmpty() :是否为空
      //System.out.println(c.isEmpty());
      
      
      //boolean remove(Object o) :删除元素
      //System.out.println(c.remove("java"));
      
      //int size() :返回集合中的元素个数
      //System.out.println(c.size());
      
      //Object[] toArray()  :将集合转换成一个Object类型的数组
      Object[] objs = c.toArray();
      for (int i = 0; i < objs.length; i++) {
          System.out.println(objs[i]);
      }
      System.out.println(c);
  }
}
  • 迭代器
  • java中提供了很多个集合,它们在存储元素时,采用的存储方式不同。我们要取出这些集合中的元素,可通过一种通用的获取方式来完成。
    Collection集合元素的通用获取方式:在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
  • 集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下
    hasNext()方法:判断集合中是否有元素可以迭代
    next()方法:用来返回迭代的下一个元素,并把指针向后移动一位。
  • 案例代码三:
package com.neuedu.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
* 集合的遍历方式:
*         1.toArray(),可以把集合转换成数组,然后遍历数组即可
*         2.iterator(),可以返回一个迭代器对象,我们可以通过迭代器对象来迭代集合
* 
* Iterator:可以用于遍历集合
*     E next()  :返回下一个元素
*  boolean hasNext()  :判断是否有元素可以获取
* 
*  注意:Exception in thread "main" java.util.NoSuchElementException
*     使用next方法获取下一个元素,如果没有元素可以获取,则出现NoSuchElementException
  
*/
public class IteratorDemo {
  public static void main(String[] args) {
      //method();
      //创建集合对象
      Collection c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      
      //获取迭代器对象
      Iterator it = c.iterator();
      
      //Object next()  :返回下一个元素
      //boolean hasNext()  :判断是否有元素可以获取
      
      /*if(it.hasNext())
          System.out.println(it.next());
      if(it.hasNext())
          System.out.println(it.next());
      if(it.hasNext())
          System.out.println(it.next());
      if(it.hasNext())
          System.out.println(it.next());*/
      
      while(it.hasNext()) {
          System.out.println(it.next());
      }
  }

  private static void method() {
      //创建集合对象
      Collection c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      //获取数组
      Object[] objs = c.toArray();
      //遍历数组
      for (int i = 0; i < objs.length; i++) {
          System.out.println(objs[i]);
      }
  }
}
  • 并发修改异常:
  • 并发修改异常产生原因:
    当使用迭代器遍历集合的时候,使用了集合中的 增加/删除 方法,导致并发修改异常产
  • 案例代码四:
package com.neuedu.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/*
* 需求:判断集合中是否包含元素java,如果有则添加元素android
* Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
* 迭代器是依赖于集合的,相当于集合的一个副本,当迭代器在操作的时候,如果发现和集合不一样,则抛出异常
* 
* 解决方案:
*         你就别使用迭代器
*         在使用迭代器进行遍历的时候使用迭代器来进行修改
*/
public class IteratorDemo3 {
  public static void main(String[] args) {
      //method();
      
      //创建集合对象
      //Collection c = new ArrayList();
      List c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      
      //我们可以通过遍历来获取集合中的每一个元素,然后进行比较即可
      /*Iterator it = c.iterator();
      while(it.hasNext()) {
          String s = (String)it.next();
          if(s.equals("java")) {
              c.add("android");
          }
      }*/
      
      ListIterator lit = c.listIterator();
      while(lit.hasNext()) {
          String s = (String)lit.next();
          if(s.equals("java")) {
              lit.add("android");
          }
      }
      
      System.out.println(c);
  }

  private static void method() {
      //创建集合对象
      Collection c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      //判断集合中是否包含元素java
      if(c.contains("java")) {
          c.add("android");
      }
      System.out.println(c);
  }
}
二、增强for&泛型
  • 泛型
  • 泛型的引入
    在前面学习集合时,我们都知道集合中是可以存放任意对象的,只要把对象存储集合后,那么这时他们都会被提升成Object类型。当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换
  • 案例代码五:
package com.neuedu.demo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
* 使用集合存储自定义对象并遍历
* 由于集合可以存储任意类型的对象,当我们存储了不同类型的对象,就有可能在转换的时候出现类型转换异常,
* 所以java为了解决这个问题,给我们提供了一种机制,叫做泛型
*             
*/
public class GenericDemo {
  public static void main(String[] args) {
      //创建集合对象
      Collection  c = new ArrayList();
      //创建元素对象
      Student s = new Student("zhangsan",18);
      Student s2 = new Student("lisi",19);
      //添加元素对象
      c.add(s);
      c.add(s2);
      //遍历集合对象
      
      Iterator  it = c.iterator();
      while(it.hasNext()) {
           String str = (String)it.next();
           System.out.println(str); 
      }
  }
}

class Student {
  String name;
  int age;
  public Student(String name,int age) {
      this.name = name;
      this.age = age;
  }
}

以上代码会发生强制转换异常,原因就是String str = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发声强制转换异常的问题

  • 泛型的使用
    当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:
    class ArrayList<E>,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型
    ArrayList<String> al=new ArrayList<String>(),那么String就把E替换掉了
  • 案例代码六:
package com.neuedu.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/*
* 使用集合存储自定义对象并遍历
* 由于集合可以存储任意类型的对象,当我们存储了不同类型的对象,就有可能在转换的时候出现类型转换异常,
* 所以java为了解决这个问题,给我们提供了一种机制,叫做泛型
* 
* 泛型:是一种广泛的类型,把明确数据类型的工作提前到了编译时期,借鉴了数组的特点
* 泛型好处:
*             避免了类型转换的问题
*             可以减少黄色警告线
*             可以简化我们代码的书写
* 
* 什么时候可以使用泛型?
*         问API,当我们看到<E>,就可以使用泛型了
*             
*/
public class GenericDemo {
  public static void main(String[] args) {
      //创建集合对象
      Collection<Student> c = new ArrayList<Student>();
      //创建元素对象
      Student s = new Student("zhangsan",18);
      Student s2 = new Student("lisi",19);
      //添加元素对象
      c.add(s);
      c.add(s2);
      //遍历集合对象
      
      Iterator<Student> it = c.iterator();
      while(it.hasNext()) {
          //String str = (String)it.next();
          //System.out.println(str);
          
          Student stu = it.next();
          System.out.println(stu.name);
      }
  }
}

class Student {
  String name;
  int age;
  
  public Student(String name,int age) {
      this.name = name;
      this.age = age;
  }
}
  • 增强for

增强for循环是JDK1.5以后出来的一个高级for循环,专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。
格式:
for(元素的数据类型 变量 : Collection集合or数组){
}
它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

  • 案例代码七:
package com.neuedu.demo;
import java.util.ArrayList;
import java.util.Collection;

/*
* foreach:增强for循环,一般用于遍历集合或者数组
* 格式:
*         for(元素的类型 变量 : 集合或者数组对象) {
*             可以直接使用变量;
*         }
* 注意:在增强for循环中不能修改集合,否则会出现并发修改异常。
* 
* public interface Iterable<T>
* 实现这个接口允许对象成为 "foreach" 语句的目标。
*
*/
public class ForEachDemo {
  public static void main(String[] args) {
       //创建集合对象
      Collection<String> c = new ArrayList<String>();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      
      //增强for循环遍历集合
      /*for(Object obj : c) {
          System.out.println(obj);
      }*/
      
      
      /*for(String s : c) {
          System.out.println(s.toUpperCase());
      }*/
      
      for (String string : c) {
          c.add("android");
          System.out.println(string);
      }
  }
}
三、常见数据结构
  • 数组

数组,采用该结构的集合,对元素的存取有如下的特点:
查找元素快:通过索引,可以快速访问指定位置的元素
增删元素慢 ,每次添加元素需要移动大量元素或这创建新的数组


数组.png
  • 链表

链表,采用该结构的集合,对元素的存取有如下的特点:

  • A:多个节点之间,通过地址进行连接。例如,多个人手拉手,每个人使用自己的右手拉住下个人的左手,依次类推,这样多个人就连在一起了。
  • B:查找元素慢:想查找某个元素,需要通过连接的节点,依次向后查找指定元素
  • C:增删元素快:
    增加元素:只需要修改连接下个元素的地址即可。
    删除元素:只需要修改连接下个元素的地址即可


    链表.png
  • 栈&队列
  • A:堆栈,采用该结构的集合,对元素的存取有如下的特点:
    先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先弹出上面的子弹,然后才能弹出下面的子弹。
  • B:队列,采用该结构的集合,对元素的存取有如下的特点:
    先进先出(即,存进去的元素,要在后它前面的元素依次取出后,才能取出该元素)。例如,安检。排成一列,每个人依次检查,只有前面的人全部检查完毕后,才能排到当前的人进行检查。


    栈和队列.png
四、List子体系
  • List子体系特点
  • A:有序的(存储和读取的顺序是一致的)
  • B:有整数索引
  • C:允许重复的
  • List的特有功能
  • void add(int index, E element) :将元素添加到index索引位置上
  • E get(int index) :根据index索引获取元素
  • E remove(int index) :根据index索引删除元素
  • E set(int index, E element):将index索引位置的的元素设置为element
  • 案例代码八:
package com.neuedu.demo;
import java.util.ArrayList;
import java.util.List;
/*
* List:
*         有序的(存储和读取的顺序是一致的)
*         有整数索引
*         允许重复的
* 
* List的特有功能:
*             void add(int index, E element)  
*             E get(int index)  
*             E remove(int index)  
*         E set(int index, E element)
*  
*   增删改查
*   
*/
public class ListDemo {
  public static void main(String[] args) {
      //创建的列表对象
      List list = new ArrayList();
      
      //void add(int index, E element)  : 在指定索引位置添加指定元素
      list.add(0, "hello");
      list.add(0, "world");
      list.add(1, "java");
      
      //E get(int index)  :根据索引返回元素
      /*System.out.println(list.get(0));
      System.out.println(list.get(1));
      System.out.println(list.get(2));*/
      //System.out.println(list.get(3));
      
      /*for (int i = 0; i < list.size(); i++) {
          System.out.println(list.get(i));
      }*/
      
      //E remove(int index)  : 删除指定元素并返回
      
      //System.out.println(list.remove(5));
      
      //E set(int index, E element) : 将指定索引位置的元素替换为指定元素,并将原先的元素返回
      System.out.println(list.set(0, "android"));
      
      System.out.println(list);
  }
}
  • LinkedList特有功能
  • LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢
    void addFirst(E e) :向链表的头部添加元素
    void addLast(E e):向链表的尾部添加元素
    E getFirst():获取链头的元素,不删除元素
    E getLast():获取链尾的元素,不删除元素
    E removeFirst():返回链头的元素并删除链头的元素
    E removeLast():返回链尾的元素并删除链尾的元素
  • 案例代码九:
package com.neuedu.demo
import java.util.LinkedList;

/*
* List的常用子类:
*         ArrayList
*             底层是数组结构,查询快,增删慢
*         LinkedList
*             底层结构是链表,查询慢,增删快
* 
* 如何选择使用不同的集合?
*         如果查询多,增删少,则使用ArrayList
*         如果查询少,增删多,则使用LinkedList
*         如果你不知道使用什么,则使用ArrayList
* 
* LinkedList的特有功能:
*             void addFirst(E e)  
*             void addLast(E e) 
*             E getFirst()  
*             E getLast()  
*             E removeFirst() 
*             E removeLast() 
*                 
*/
public class LinkedListDemo {
  public static void main(String[] args) {
          LinkedList list = new LinkedList();
          list.add("hello");
          list.add("world");
      
          //void addFirst(E e)  :将元素添加到索引为0的位置
          //void addLast(E e) :将元素添加到索引为size()-1的位置
          list.addFirst("java");
          list.addLast("android");
          
          //E getFirst()  :获取索引为0的元素
          //E getLast()  :获取索引为size()-1的元素
          //System.out.println(list.getFirst());
          //System.out.println(list.getLast());
          
          //E removeFirst() :删除索引为0的元素并返回
          //E removeLast() :删除索引为size()-1的元素并返回
          System.out.println(list.removeFirst());
          System.out.println(list.removeLast());
                      
          System.out.println(list);
  }
}
package com.neuedu.demo;
import java.util.ArrayList;
import java.util.List;
/*
* 需求:定义一个方法,返回指定列表中指定元素的索引位置
*
* 判断元素是否存在
*
*/
public class ListTest {
public static void main(String[] args) {
List list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
//int index = index(list,"php");
//System.out.println(index);
//boolean flag = contains(list, "php");
//System.out.println(flag);
boolean flag = list.contains("php");
System.out.println(flag);
}
public static int index(List list,Object other) {
for(int x = 0;x < list.size();x++) {

//获取列表中的元素
Object obj = list.get(x);

//使用列表中的元素和指定的元素进行比较
if(obj.equals(other)) {
return x;
}
}

//查找不到指定的元素
return -1;
}
public static boolean contains(List list,Object other) {
//获取指定元素在指定列表中的索引位置
int index = index(list,other);
//如果索引位置大于等于0,则认为元素存在,否则不存在
if(index >= 0) {
return true;
}
else {
return false;
}
}
}
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 206,723评论 6 481
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 88,485评论 2 382
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 152,998评论 0 344
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 55,323评论 1 279
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 64,355评论 5 374
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,079评论 1 285
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 38,389评论 3 400
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,019评论 0 259
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 43,519评论 1 300
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,971评论 2 325
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,100评论 1 333
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 33,738评论 4 324
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,293评论 3 307
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,289评论 0 19
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,517评论 1 262
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 45,547评论 2 354
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 42,834评论 2 345

推荐阅读更多精彩内容

  • mean to add the formatted="false" attribute?.[ 46% 47325/...
    ProZoom阅读 2,693评论 0 3
  • 转载自:Java集合框架实例 1- 介绍 集合是程序和语言的基本思想。应用程序通常都会应用到集合,例如雇员的信息,...
    01_小小鱼_01阅读 387评论 0 1
  • 【程序1】 题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔...
    开心的锣鼓阅读 3,307评论 0 9
  • List:元素是有序的(怎么存的就怎么取出来,顺序不会乱),元素可以重复(角标1上有个3,角标2上也可以有个3)因...
    壹米玖坤阅读 1,199评论 0 1
  • 6.7 6.8认真早读中,坐姿端正! 五年级早读,学生自主管理,依然很认真! 五年级,六年级午写认真,并展示了正...
    sunshine271阅读 311评论 0 0