C.编译运行都正常,Collection接口方法

1、Collection集合-概述

01集合使用的回顾

 *A:集合使用的回顾
   *a.ArrayList集合存储5个int类型元素
      public static void main(String[] args) {
           ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(111);
        list.add(222);
        list.add(333);
        list.add(444);
        list.add(555);
        for(int i=0; i<list.size(); i++){
               System.out.println(list.get(i));
       }
      }

  *b.ArrayList集合存储5个Person类型元素
     public static void main(String[] args) {
      ArrayList<Person> list = new ArrayList<Person>();
      list.add(new Person(“小强”));
      list.add(new Person(“老王”));
      list.add(new Person(“小虎”));
      list.add(new Person(“小泽”));
      list.add(new Person(“小红”));
      for(int i=0; i<list.size(); i++){
        Person p = list.get(i);
              System.out.println(p);
       }
     }

Java集合和泛型练习及面试题——博客园:执、著,java试题

给定一段JAVA代码如下:要打印出list中存储的内容,以下语句正确的是( B  )

ArrayList list = new ArrayList( )  

list.add(“a”)  

list.add(“b”)  

Iterator it = list.iterator( ) 

A.while(it. Next( ) )   system.out.println(it.next( ) )

B.for(int i=0; i<list.size( )  i++)   system.out.println(list.get(i))  

C.while(list.hasNext( ) )   system.out.println(list.next( ) ) 

D.for(int i=0; i<list.size( )  i++)   system.out.println(it(i))  

下面代码运行结果正确的是(C )

 import java.util.*; 

public class TestListSet{ 

  public static void main(String args[]){ 

    List list = new ArrayList(); 

    list.add(“Hello”);

    list.add(“Learn”);

     list.add(“Hello”);

     list.add(“Welcome”);

    Set set = new HashSet(); 

    set.addAll(list); 

    System.out.println(set.size()); 

  } 

}  

A.编译不通过                   B.编译通过,运行时异常  

C.编译运行都正常,//输出HashSet中不能放重复值  D.编译运行都正常,输出4

在java中,( B)接口位于集合框架的顶层

A.Map  B.Collection  C.Set  D.List

在JAVA中,以下( C )类的对象以键-值的方式存储对象

A.java.util.List   B.java.util.ArrayList  C.java.util.HashMap  D.java.util.LinkedList

在JAVA中ArrayList类实现了可变大小的数组,便于遍历元素和随机访问元素,已知获得了ArrayList类的对象bookTypeList,则下列语句中能够实现判断列表中是否存在字符串“小说”的是(C )

A.bookTypeList.add("小说");       B.bookTypeList.get("小说"); 

C.bookTypeList.contains("小说");      D.bookTypeList.remove("小说"); 

下面叙述哪些是正确的?(ABC  )

A.java中的集合类(如Vector)可以用来存储任何类型的对象,且大小可以自动调整。但需要事先知道所存储对象的类型,才能正常使用

B.在java中,可以用异常(Exception)来抛出一些并非错误的消息,但这样比直接从函数返回一个结果要花费更大的系统开销。

C.java接口包含函数声明和常量声明。

D.java中,子类不可以访问父类的私有成员和受保护的成员

在JAVA中,LinkedList类和ArrayList类同属于集合框架类,下列(ABC )选项中的方法是LinkedList类ArrayList类都有的

A.add(Object o)  B.add(int index,Object o)  C.remove(Object o)   D.removeLast()

请分析下面程序编译并运行的结果

class MyNumberException<T> extends Exception{

  public MyNumberException(String message){

    super(message);

  }

}

public class GenericsTest{

  public static void main(String[] args){

    int num=1;

    try{

      if(num<10){

        throw new MyNumberException("数字小于10");

      }

    }catch(MyNumberException e){

      System.out.println(e);

    }catch(Exception e){

      System.out.println(e);

    }

  }

}

解析:在Java中泛型类继承Throwable及其子类都是不合法的,所以上面的程序编译无法通过

已知:

public class ListTest{

  public static void main(String[] args){

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

    link.add("1");

    link.add("2");

    link.add("3");

    link.addFirst("F");

    link.addLast("L");

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

      link.remove(i);

    }

    System.out.println(link);

  }

}

程序运行结果:[1,3]

解析:添加完元素后,集合中的元素顺序为[F,1,2,3,L],各个元素对应索引位置为0,1,2,3,4 执行第一次循环,i=0,删除F,集合变为[1,2,3,L],各个元素对应的索引位置为0,1,2,3   执行第二次循环:i=1,删除2,集合变为[1,3,L],各个元素对应的索引位置为0,1,2  执行第三次循环:i=2,删除L,集合变为[1,3],各个元素对应的索引位置为0,1 所以程序结束,结果为[1,3]

利用Map,完成下面的功能:

 从命令行读入一个字符串,表示一个年份,输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯,则输出:没有举办世界杯。

 附:世界杯冠军以及对应的夺冠年份

public class Bk {

  public static void main(String[] args) { 

    BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 

    String year=null; 

     try { 

      year=br.readLine();  

    } catch (IOException e) {  

      e.printStackTrace();  

    }

    Map<String,String> map=new HashMap<String, String>();  

    map.put("2002", "巴西"); 

    map.put("2006", "意大利"); 

    map.put("2010","南非");  

    if(map.containsKey(year)){  

      System.out.println(map.get(year));  

    }  

    else{ 

      System.out.println("这一年没有承办世界杯!");  

    } 

  }   

}

完善下列代码,实现把List 中的内容放到一个Map 中,该Map 的键为id值为相应的Account 对象。最后遍历这个Map,打印所有Account 对象的id 和余额

public class Test{

  public static void main(String[] args) {

    List list=new ArrayList();

    list.add(new Account(10.00,"1234"));

    list.add(new Account(15.00,"5678"));

    list.add(new Account(0.0,"1010"));

    Map map=new HashMap();

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

      Account account=(Account)list.get(i);

      map.put(account.getId(), account);

    }

    Set<Map.Entry<Long,Object>> set=map.entrySet();

    for(Map.Entry<Long, Object> obj:set){

      Account acc=(Account)obj.getValue();

      System.out.println(obj.getKey()+"/"+acc.getBalance());

    }

  }

}

class Account{

  private long id;

  private double balance;

  private String password;

  public Account(){}

  public Account(double balance,String password){

    this.id=new Random().nextLong();

    this.balance=balance;

    this.password=password;

  }

  public long getId() {

    return id;

  }

  public void setId(long id) {

    this.id = id;

  }

  public double getBalance() {

    return balance;

  }

  public void setBalance(double balance) {

    this.balance = balance;

  }

  public String getPassword() {

    return password;

  }

  public void setPassword(String password) {

    this.password = password;

  }

}

写出下面程序的输出结果

import java.util.*; 

class MyClass{ 

  int value; 

  public MyClass(){} 

  public MyClass(int value){ 

    this.value = value; 

  } 

  public String toString(){ 

    return value;

  } 

public class TestList{ 

  public static void main(String args[]){ 

    MyClass mc1 = new MyClass(10); 

    MyClass mc2 = new MyClass(20);

    MyClass mc3 = new MyClass(30); 

    List list = new ArrayList(); 

    list.add(mc1); 

    list.add(mc2); 

    list.add(mc3); 

    MyClass mc4 = (MyClass) list.get(1);

    //MyClass mc4=(MyClass)mc2; 

    mc4.value = 50; 

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

      System.out.println(list.get(i)); 

    } 

  } 

}

程序运行结果:

10

50

30

使用HashMap完成学生信息的管理功能,主要功能包括:添加学生数据、打印学生名单、删除学生数据、按学号查询学生信息四个功能。并实现持久化保存

//Java序列化是指把Java对象转换为字节序列的过程;而Java反序列化是指把字节序列恢复为Java对象的过程

public class Student implements Serializable{

private static final long serialVersionUID = 1L;

private String sno;

private String name;

private String gender;

private int age;

public Student(String sno,String name,String gender,int age){

super();

this.sno=sno;

this.name=name;

this.gender=gender;

this.age=age;

}

public String getSno() {

return sno;

}

public void setSno(String sno) {

this.sno = sno;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getGender() {

return gender;

}

public void setGender(String gender) {

this.gender = gender;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String toString(){

return sno+"t"+name+"t"+gender+"t"+age;

}

}

 

public interface DAOStudent {

public boolean saveAll(HashMap<String, Student> students);

public HashMap<String, Student> getAll();

}

 

public class ImplDAOStudent implements DAOStudent{

@Override

public HashMap<String, Student> getAll() {

HashMap<String,Student> hm=new HashMap<String, Student>();

File file=new File("student.txt");

ObjectInputStream ois=null;

try{

ois=new ObjectInputStream(new FileInputStream(file));

if(file.length()!=0){

hm=(HashMap<String, Student>)ois.readObject();

}

ois.close();

}catch(Exception e){

e.printStackTrace();

}

return hm;

}

@Override

public boolean saveAll(HashMap<String, Student> students){

File file=new File("student.txt");

long l=file.length();

ObjectOutputStream oos=null;

try{

oos=new ObjectOutputStream(new FileOutputStream(file));

oos.writeObject(students);

oos.close();

}catch(Exception e){

e.printStackTrace();

}

if(file.length()>l){

return true;

}

else {

return false;

}

}

}

 

public class StudentControl {

private static DAOStudent DAOstu=new ImplDAOStudent();

private static HashMap<String,Student> students;

public  static StudentControl st=new StudentControl();

static{

students=DAOstu.getAll();

}

private StudentControl(){}

public static StudentControl getInstance(){

return st;

}

public boolean addStudent(Student s){

if(!students.containsKey(s.getSno())){

students.put(s.getSno(), s);

return true;

}else{

return false;

}

}

public ArrayList<Student> getAll(){

ArrayList<Student> al=new ArrayList<Student>();

Set<Map.Entry<String, Student>> set=students.entrySet();

Iterator<Map.Entry<String,Student>> it=set.iterator();

while(it.hasNext()){

Map.Entry<String,Student> entry= it.next();

Student stu=entry.getValue();

al.add(stu);

}

return al;

}

public boolean deleteStudent(String sno){

if(students.containsKey(sno)){

students.remove(sno);

return true;

}else{

return false;

}

}

public Student queryStudentBySno(String sno){

if(students.containsKey(sno)){

return students.get(sno);

}else

return null;

}

public boolean exitSystem(){

return DAOstu.saveAll(students);

}

}

 

public class ViewStudent {

public void menu(){

System.out.println("*********************");

System.out.println("请选择需要的功能:");

System.out.println("1.添加学生数据");

System.out.println("2.打印学生名单");

System.out.println("3.删除学生数据");

System.out.println("4.打印对应学号的学生数据");

System.out.println("0.退出系统");

System.out.println("**********************");

}

}

 

public class ManageStudent{

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

StudentControl sco=StudentControl.getInstance();

while(true){

new ViewStudent().menu();

int count=sc.nextInt();

switch(count){

case 1: System.out.println("请输入学生信息:");

System.out.print("姓名:");

String name=sc.next();

System.out.print("学号:");

String sno=sc.next();

System.out.print("性别:");

String gender=sc.next();

System.out.print("年龄:");

int age=sc.nextInt();

Student student=new Student(sno,name,gender,age);

if(sco.addStudent(student)){

System.out.println("操作成功");

}else{

System.out.println("操作失败");

}

break;

case 2:

System.out.println("学号tt姓名t性别t年龄");

ArrayList<Student> list=sco.getAll();

Iterator<Student> it=list.iterator();

while(it.hasNext()){

Student stu=it.next();

System.out.println(stu.toString());

}

break;

case 3:System.out.println("请输入需要删除的学生的学号:");

String string=sc.next();

if(sco.deleteStudent(string)){

System.out.println("操作成功");

}else{

System.out.println("操作失败");

}

break;

case 4:System.out.println("输入你要查找的学号:");

String str=sc.next();

Student stu=sco.queryStudentBySno(str);

System.out.println("学号tt姓名t性别t年龄");

System.out.println(stu.toString());

break;

case 0:

sco.exitSystem();

System.exit(0);

default:System.out.println("输入有误,请重新输入");

}

}

}

}

 

输入学生信息,按学生成绩排序

public class Stu{

private String name;

private int score;

public Stu(){}

public Stu(String name,int score){

this.name=name;

this.score=score;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getScore() {

return score;

}

public void setScore(int score) {

this.score = score;

}

public String toString(){

return name+":"+score;

}

}

 

public class CompareScore implements Comparator<Stu>{

public boolean equals(Object obj){

return super.equals(obj);

}

@Override

public int compare(Stu s1, Stu s2) {

if(s1.getScore()>s2.getScore()){

return -1;

}else if(s1.getScore()<s2.getScore()){

return 1;

}else{

return s2.getName().compareTo(s1.getName());

}

}

}

 

public class DemoTreeSet {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);

TreeSet<Stu> ts=new TreeSet<Stu>(new CompareScore());

while(true){

System.out.print("给出你的选择(1.添加信息、2.降序输出、3.退出程序):");

int num=sc.nextInt();

switch(num){

case 1:

System.out.print("输入学生的姓名:");

String name=sc.next();

System.out.print("输入学生的成绩:");

int score=sc.nextInt();

ts.add(new Stu(name,score));

break;

case 2:System.out.println(ts);

break;

case 0:System.exit(0);

default:System.out.println("输入有误,请重新输入");

}

}

}

}

 

使用泛型得到数组的最大和最小值

interface MaxOrMin<T extends Comparable<T>>{

T min(T[] t);

T max(T[] t);

}

public class TextMinOrMax {

public static void main(String[] args) {

Integer[] in=new Integer[]{43,52,66,71,39,33};

Character[] ch=new Character[]{'f','v','d','t','z'};

ComparableElement<Integer> ce1=new ComparableElement<Integer>();

System.out.println("int数组的最大值:"+ce1.max(in)+",最小值:"+ce1.min(in));

ComparableElement<Character> ce2=new ComparableElement<Character>();

System.out.println("char数组的最大值:"+ce2.max(ch)+",最小值:"+ce2.min(ch));

}

}

class ComparableElement<T extends Comparable<T>> implements MaxOrMin<T>{

T max;

T min;

@Override

public T max(T[] t) {

 max=t[0];

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

 if(max.compareTo(t[i])<0){

 max=t[i];

 }

 }

return max;

}

@Override

public T min(T[] t) {

 min=t[0];

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

 if(min.compareTo(t[i])>0){

 min=t[i];

 }

 }

return min;

}

}

Iterator与ListIterator有什么区别?

Iterator:只能正向遍历集合,适用于获取移除元素。ListIerator:继承Iterator,可以双向列表的遍历,同样支持元素的修改。

Collection和Collections的区别

答:Collection:是java.util包中的接口,是集合类的基本接口,主要的子接口有List和Set

Collections:是java.util包中的类,是针对集合的一个实用工具类,它包含了对各种集合的搜索、排序和线程安全等一系列的静态方法。

ArrayList与Vector的异同

答:相同点:ArrayList和Vector都是List的子类,都是有序的集合,可以存储相同的元素,相当于动态数组,他们都可以按索引位置取得指定的元素。

区别:(1)出现的时间:Vector是在JDK1.0就已存在,而ArrayList到了JDK1.2才推出。

(2)同步性:Vector是线程安全的,也就是说它的方法之间是线程同步的,而ArrayList是线程不安全的,它的方法之间是线程不同步的。在程序设计中,如果是只有一个线程会访问到集合,最好选择使用ArrayList,因为他不考虑线程安全,效率会高些;如果多个线程会访问到集合,最好选择使用Vector,因为不需要开发人员自己编写线程安全的代码。

(3)数据增长:ArrayList与Vector都存在初始的容量大小,且都为10,当存储进集合里的元素的个数超过了容量时,就需要增加ArrayList与Vector的存储空间。每次要增加存储空间时,不是只增加一个存储单元,而是增加多个存储单元。这就要求每次增加的存储单元的个数在内存空间利用与线程效率之间要取得一定的平衡。Vector默认增长为原来一倍,而ArrayList的增长策略在文档中没有明确规定(从源代码看到的是增长为原来的一半)

(4)输出方式:Vector可以使用Iterator、foreach和Enumeration方式输出,而ArrayList只能使用Iterator、foreach方式输出

简述HashMap与Hashtable的异同

答:相同点:HashMap与Hashtable都是Map接口的实现类,而HashMap是Hashtable的轻量级实现(非线程安全的实现)。两者都是用key-value方式获取数据。

区别:(1)出现的时间:Hashtable在JDK1.0时出现,属于旧的操作类,而HashMap是在JDK1.2时推出的类,属于较新的操作类

(2)同步性:Hashtable是线程安全的,也就是说是同步的,性能相对较低,而HashMap是线程不安全的,不是同步的,性能相对较高。

(3)值:Hashtable不允许存放null值和null键,而HashMap允许存在一个null键和多个null值

(4)HashMap没法保证映射的顺序一直不变,但是作为HashMap的子类LinkedHashMap,如果想要预知的顺序迭代(默认按照插入顺序),你可以很轻易的置换为HashMap,如果使用Hashtable就没那么容易了。

(5)迭代HashMap采用快速失败机制,而Hashtable不是,所以这是设计的考虑点

ArrayList中的浅拷贝与深拷贝

浅拷贝:被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。  

深拷贝:被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍.(eg:  1、直接赋值(字符串外都属于浅拷贝)  2、使用构造函数(深拷贝)  3、使用clone()方法(深拷贝)  )

ArrayList中为何加transient关键字?

   transient是Java语言的关键字,变量修饰符,如果用transient声明一个实例变量,当对象存储时,它的值不需要维持。这里的对象存储是指,Java的serialization提供的一种持久化对象实例的机制。当一个对象被序列化的时候,transient型变量的值不包括在序列化的表示中,然而非transient型的变量是被包括进去的。使用情况是:当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。

Java中的泛型是什么 ? 使用泛型的好处是什么?

泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。

Java的泛型是如何工作的 ? 什么是类型擦除?

Java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会在编译器在编译的时候去掉。这个过程就称为类型擦除。

请举例说明static和泛型的冲突所在

泛型类确定T的类型实在运行是时期,而static在编译时期已经存在。

 

 

给定一段JAVA代码如下:要打印出list中存储的内容,以下语句正确的是(B) Ar...

1)、集合是一个装”引用类型”的”容器”

02集合的学习目标

   集合,集合是java中提供的一种容器,可以用来存储多个数据。
 在前面的学习中,我们知道数据多了,可以使用数组存放或者使用ArrayList集合进行存放数据。那么,集合和数组既然都是容器,它们有啥区别呢?
   数组的长度是固定的。集合的长度是可变的。
   集合中存储的元素必须是引用类型数据

2)、Java内部提供了很多”集合类”,每种集合类对元素的存储采用了不同的”数据结构”–集合存储数据的方式。

03集合继承关系图

A:集合继承关系图
 a:ArrayList的继承关系:
 查看ArrayList类发现它继承了抽象类AbstractList同时实现接口List,而List接口又继承了Collection接口。Collection接口为最顶层集合接口了。
 源代码:
  interface List extends Collection {
  }
  public class ArrayList extends AbstractList implements List{
  }

b:集合继承体系
 这说明我们在使用ArrayList类时,该类已经把所有抽象方法进行了重写。那么,实现Collection接口的所有子类都会进行方法重写。
   Collecton接口常用的子接口有:List接口、Set接口
   List接口常用的子类有:ArrayList类、LinkedList类
   Set接口常用的子类有:HashSet类、LinkedHashSet类

                          Collection 接口     
                               |
 ----------------------------------------------------------------
 |                                                              |
List接口                                                       Set接口
 |                                                              |

| | | |
ArrayList类 LinkedList类 HashSet类 LinkedHashSet类

3)、这些数据结构都是各有千秋,有的增删快,查询慢;有的增删慢,查询快

04集合Collection的方法

A:集合Collection的方法
 /*
  *  Collection接口中的方法
  *  是集合中所有实现类必须拥有的方法
  *  使用Collection接口的实现类,程序的演示
  *  ArrayList implements List
  *  List extends Collection
  *  方法的执行,都是实现的重写
  */
 public class CollectionDemo {
  public static void main(String[] args) {
    function_2();
  }


  /*  Collection接口方法
   *  Object[] toArray() 集合中的元素,转成一个数组中的元素, 集合转成数组
   *  返回是一个存储对象的数组, 数组存储的数据类型是Object
   */
  private static void function_2() {
    Collection<String> coll = new ArrayList<String>();
    coll.add("abc");
    coll.add("itcast");
    coll.add("itheima");
    coll.add("money");
    coll.add("123");

    Object[] objs = coll.toArray();
    for(int i = 0 ; i < objs.length ; i++){
      System.out.println(objs[i]);
    }
  }
  /*
   * 学习Java中三种长度表现形式
   *   数组.length 属性  返回值 int
   *   字符串.length() 方法,返回值int
   *   集合.size()方法, 返回值int
   */

  /*
   * Collection接口方法
   * boolean contains(Object o) 判断对象是否存在于集合中,对象存在返回true
   * 方法参数是Object类型
   */
  private static void function_1() {
    Collection<String> coll = new ArrayList<String>();
    coll.add("abc");
    coll.add("itcast");
    coll.add("itheima");
    coll.add("money");
    coll.add("123");

    boolean b = coll.contains("itcast");
    System.out.println(b);
  }


  /*
   * Collection接口的方法
   * void clear() 清空集合中的所有元素
   * 集合容器本身依然存在
   */
  public static void function(){
    //接口多态的方式调用
    Collection<String> coll = new ArrayList<String>();
    coll.add("abc");
    coll.add("bcd");
    System.out.println(coll);

    coll.clear();

    System.out.println(coll);

  }
 }

4)、常用数据结构:

05集合Collection的remove方法

A:05集合Collection的remove方法
/*
*美高梅棋牌官网 , Collection接口方法
* boolean remove(Object o)移除集合中指定的元素
*/
private static void function_3(){
Collection<String> coll = new ArrayList<String>();
coll.add("abc");
coll.add("money");
coll.add("itcast");
coll.add("itheima");
coll.add("money");
coll.add("123");
System.out.println(coll);

  boolean b = coll.remove("money");
  System.out.println(b);
  System.out.println(coll);
}

=======================第二节课开始=============================================

​ 1)、数组:ArrayList(增删慢,查询快,常用于查询)

06迭代器的概述

A:迭代器概述:
a:java中提供了很多个集合,它们在存储元素时,采用的存储方式不同。
我们要取出这些集合中的元素,可通过一种通用的获取方式来完成。

b:Collection集合元素的通用获取方式:在取元素之前先要判断集合中有没有元素,
如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

c:每种集合的底层的数据结构不同,例如ArrayList是数组,LinkedList底层是链表,但是无论使用那种集合,我们都会有判断是否有元素
以及取出里面的元素的动作,那么Java为我们提供一个迭代器定义了统一的判断元素和取元素的方法

​ 2)、链表:LinkedList(增删快,查询慢,常用于操作数据)

07迭代器的实现原理

A:迭代器的实现原理
/

* 集合中的迭代器:
* 获取集合中元素方式
* 接口 Iterator : 两个抽象方法
* boolean hasNext() 判断集合中还有没有可以被取出的元素,如果有返回true
* next() 取出集合中的下一个元素
*
* Iterator接口,找实现类.
* Collection接口定义方法
* Iterator iterator()
* ArrayList 重写方法 iterator(),返回了Iterator接口的实现类的对象
* 使用ArrayList集合的对象
* Iterator it =array.iterator(),运行结果就是Iterator接口的实现类的对象
* it是接口的实现类对象,调用方法 hasNext 和 next 集合元素迭代
*/

​ 3)、哈希表:HashSet(增删改查都快,但每次都要生成哈希值)

08迭代器的代码实现

*A:迭代器的代码实现
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> coll = new ArrayList<String>();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//迭代器,对集合ArrayList中的元素进行取出

      //调用集合的方法iterator()获取出,Iterator接口的实现类的对象
      Iterator<String> it = coll.iterator();
      //接口实现类对象,调用方法hasNext()判断集合中是否有元素
      //boolean b = it.hasNext();
      //System.out.println(b);
      //接口的实现类对象,调用方法next()取出集合中的元素
      //String s = it.next();
      //System.out.println(s);

      //迭代是反复内容,使用循环实现,循环的条件,集合中没元素, hasNext()返回了false
      while(it.hasNext()){
        String s = it.next();
        System.out.println(s);
      }



    }
  }

​ ……

09迭代器的执行过程

A:迭代器的执行过程
a:迭代器的原理:
while(it.hasNext()) {
System.out.println(it.next());
}

   //cursor记录的索引值不等于集合的长度返回true,否则返回false
     public boolean hasNext() {       
       return cursor != size; //cursor初值为0

     }

    //next()方法作用:
    //①返回cursor指向的当前元素 
    //②cursor++
    public Object next() {            
             int i = cursor; 
             cursor = i + 1;  
             return  elementData[lastRet = i]; 

         }
 b:for循环迭代写法:
    for (Iterator<String> it2 = coll.iterator(); it2.hasNext();  ) {
     System.out.println(it2.next());
   } 

5)、集合体系

10集合迭代中的转型

A:集合迭代中的转型
a:在使用集合时,我们需要注意以下几点:
 集合中存储其实都是对象的地址。
 集合中可以存储基本数值吗?jdk1.5版本以后可以存储了。
因为出现了基本类型包装类,它提供了自动装箱操作(基本类型对象),这样,集合中的元素就是基本数值的包装类对象。

b:存储时提升了Object。取出时要使用元素的特有内容,必须向下转型。
 Collection coll = new ArrayList();
 coll.add("abc");
 coll.add("aabbcc");
 coll.add("shitcast");
 Iterator it = coll.iterator();
 while (it.hasNext()) {
  //由于元素被存放进集合后全部被提升为Object类型
 //当需要使用子类对象特有方法时,需要向下转型
  String str = (String) it.next();
  System.out.println(str.length());
 }
 注意:如果集合中存放的是多个对象,这时进行向下转型会发生类型转换异常。


c:Iterator接口也可以使用<>来控制迭代元素的类型的。代码演示如下:
 Collection<String> coll = new ArrayList<String>();
 coll.add("abc");
 coll.add("aabbcc");
 coll.add("shitcast");
 Iterator<String> it = coll.iterator();
 while (it.hasNext()) {
  String str =  it.next(); 
 //当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
  System.out.println(str.length());
 }

=========================第三节课开始====================================

美高梅棋牌游戏 1

11增强for循环遍历数组

A:增强for循环遍历数组
a:格式:
/

* JDK1.5新特性,增强for循环
* JDK1.5版本后,出现新的接口 java.lang.Iterable
* Collection开是继承Iterable
* Iterable作用,实现增强for循环
*
* 格式:
* for( 数据类型 变量名 : 数组或者集合 ){
* sop(变量);
* }
*/
public static void function_1(){
//for对于对象数组遍历的时候,能否调用对象的方法呢
String[] str = {"abc","itcast","cn"};
for(String s : str){
System.out.println(s.length());
}
}

  /*
   *  实现for循环,遍历数组
   *  好处: 代码少了,方便对容器遍历
   *  弊端: 没有索引,不能操作容器里面的元素
   */
  public static void function(){
    int[] arr = {3,1,9,0};
    for(int i : arr){
      System.out.println(i+1);
    }
    System.out.println(arr[0]);
  }

2、Collection接口中的常用功能能

12增强for循环遍历集合

  A:增强for循环遍历集合  
    /*
     *  增强for循环遍历集合
     *  存储自定义Person类型
     */
    public static void function_2(){
      ArrayList<Person> array = new ArrayList<Person>();
      array.add(new Person("a",20));
      array.add(new Person("b",10));
      for(Person p : array){
        System.out.println(p);// System.out.println(p.toString());
      }
    }

1)、添加

13泛型的引入

A:泛型的引入
在前面学习集合时,我们都知道集合中是可以存放任意对象的,
只要把对象存储集合后,那么这时他们都会被提升成Object类型。
当我们在取出每一个对象,并且进行相应的操作,这时必须采用类型转换。比如下面程序:
public class GenericDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("abc");
list.add("itcast");
list.add(5);//由于集合没有做任何限定,任何类型都可以给其中存放
//相当于:Object obj=new Integer(5);

    Iterator it = list.iterator();
    while(it.hasNext()){
      //需要打印每个字符串的长度,就要把迭代出来的对象转成String类型
      String str = (String) it.next();//String str=(String)obj;
                                      //编译时期仅检查语法错误,String是Object的儿子可以向下转型
                                      //运行时期String str=(String)(new Integer(5))
                                      //String与Integer没有父子关系所以转换失败
                                      //程序在运行时发生了问题java.lang.ClassCastException
      System.out.println(str.length());
    }
  }
}

public boolean add: 把给定的对象添加到当前集合中 。

14泛型的定义和使用

A:泛型的定义和使用
/*
* JDK1.5 出现新的安全机制,保证程序的安全性
* 泛型: 指明了集合中存储数据的类型 <数据类型>
*/

public class GenericDemo {
  public static void main(String[] args) {
    function();
  }

  public static void function(){
    Collection<String> coll = new ArrayList<String>();
    coll.add("abc");
    coll.add("rtyg");
    coll.add("43rt5yhju");
//    coll.add(1);

    Iterator<String> it = coll.iterator();
    while(it.hasNext()){
      String s = it.next();
      System.out.println(s.length());
    }
  }
}

ArrayList会永远返回true;

15Java中的伪泛型

 A:Java中的伪泛型:
   泛型只在编译时存在,编译后就被擦除,在编译之前我们就可以限制集合的类型,起到作用
 例如:ArrayList<String> al=new ArrayList<String>();
 编译后:ArrayList al=new ArrayList();

================================第四节课开始======================================================

set中添加重复元素时,返回false;

16泛型类

A:泛型类:
a:定义格式:
修饰符 class 类名<代表泛型的变量> { }

  例如,API中的ArrayList集合:
  class ArrayList<E>{ 
       public boolean add(E e){ }
    public E get(int index){  }
  }

b:使用格式:
  创建对象时,确定泛型的类型

  例如,ArrayList<String> list = new ArrayList<String>();
  此时,变量E的值就是String类型
  class ArrayList<String>{ 
    public boolean add(String e){ }
    public String get(int index){  }
  }

  例如,ArrayList<Integer> list = new ArrayList<Integer>();
  此时,变量E的值就是Integer类型
  class ArrayList<Integer>{ 
       public boolean add(Integer e){ }
       public Integer get(int index){  }
  }

2)、删除

17泛型的方法

A:泛型的方法
a:定义格式:修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
b:泛型方法的使用:
1:例如,API中的ArrayList集合中的方法:
public <T> T[] toArray(T[] a){ }
//该方法,用来把集合元素存储到指定数据类型的数组中,返回已存储集合元素的数组

  使用格式:调用方法时,确定泛型的类型
例如:
      ArrayList<String> list = new ArrayList<String>();
      String[] arr = new String[100];
      String[] result = list.toArray(arr);
   此时,变量T的值就是String类型。变量T,可以与定义集合的泛型不同
   public <String> String[] toArray(String[] a){  } 


  例如:
      ArrayList<String> list = new ArrayList<String>();
      Integer[] arr = new Integer[100];
      Integer [] result = list.toArray(arr);

  此时,变量T的值就是Integer类型。变量T,可以与定义集合的泛型不同
  public <Integer> Integer[] toArray(Integer[] a){  } 

public void clear() :清空集合中所有的元素。

18泛型的接口

A:泛型的接口:
/*
* 带有泛型的接口
*
* public interface List <E>{
* abstract boolean add(E e);
* }
*
* 实现类,先实现接口,不理会泛型
* public class ArrayList<E> implements List<E>{
* }
* 调用者 : new ArrayList<String>() 后期创建集合对象的时候,指定数据类型
*
*
* 实现类,实现接口的同时,也指定了数据类型
* public class XXX implements List<String>{
* }
* new XXX()
*/
public class GenericDemo2 {

 }

public boolean remove: 把给定的对象在当前集合中删除。

19泛型的好处

A:泛型的好处
a:将运行时期的ClassCastException,转移到了编译时期变成了编译失败。
b:避免了类型强转的麻烦。
演示下列代码:
public class GenericDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("itcast");
//list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
//集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型

    Iterator<String> it = list.iterator();
    while(it.hasNext()){
       String str = it.next();
       System.out.println(str.length()); //当使用Iterator<String>      
                                        //控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
    }
  }
}

当移除多个相同元素,只移除遇到的第一个

20泛型的通配符

A:泛型的通配符
/*
* 泛型的通配符
*/
public class GenericDemo {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<String>();

  HashSet<Integer> set = new HashSet<Integer>();

  array.add("123");
  array.add("456");

  set.add(789);
  set.add(890);

  iterator(array);
  iterator(set);
}
/*
 *  定义方法,可以同时迭代2个集合
 *  参数: 怎么实现 , 不能写ArrayList,也不能写HashSet
 *  参数: 或者共同实现的接口
 *  泛型的通配,匹配所有的数据类型  ?
 */
public static void iterator(Collection<?> coll){
  Iterator<?> it = coll.iterator();
  while(it.hasNext()){
    //it.next()获取的对象,什么类型
    System.out.println(it.next());
  }
}

}

3)、判断

21泛型的限定

A:泛型的限定
/*
* 将的酒店员工,厨师,服务员,经理,分别存储到3个集合中
* 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法
*美高梅棋牌游戏 ,/
import java.util.ArrayList;
import java.util.Iterator;
public class GenericTest {
public static void main(String[] args) {
//创建3个集合对象
ArrayList<ChuShi> cs = new ArrayList<ChuShi>();
ArrayList<FuWuYuan> fwy = new ArrayList<FuWuYuan>();
ArrayList<JingLi> jl = new ArrayList<JingLi>();

  //每个集合存储自己的元素
  cs.add(new ChuShi("张三", "后厨001"));
  cs.add(new ChuShi("李四", "后厨002"));

  fwy.add(new FuWuYuan("翠花", "服务部001"));
  fwy.add(new FuWuYuan("酸菜", "服务部002"));

  jl.add(new JingLi("小名", "董事会001", 123456789.32));
  jl.add(new JingLi("小强", "董事会002", 123456789.33));

// ArrayList<String> arrayString = new ArrayList<String>();
iterator(jl);
iterator(fwy);
iterator(cs);

}
/*
 * 定义方法,可以同时遍历3集合,遍历三个集合的同时,可以调用工作方法 work
 * ? 通配符,迭代器it.next()方法取出来的是Object类型,怎么调用work方法
 * 强制转换:  it.next()=Object o ==> Employee
 * 方法参数: 控制,可以传递Employee对象,也可以传递Employee的子类的对象
 * 泛型的限定  本案例,父类固定Employee,但是子类可以无限?
 *   ? extends Employee 限制的是父类, 上限限定, 可以传递Employee,传递他的子类对象
 *   ? super   Employee 限制的是子类, 下限限定, 可以传递Employee,传递他的父类对象
 */
public static void iterator(ArrayList<? extends Employee> array){

   Iterator<? extends Employee> it = array.iterator();
   while(it.hasNext()){
     //获取出的next() 数据类型,是什么Employee
     Employee e = it.next();
     e.work();
   }
}

}

public boolean contains: 判断当前集合中是否包含给定的对象。

public boolean isEmpty(): 判断当前集合是否为空。

4)、获取

public int size(): 返回集合中元素的个数。

public Object[] toArray(): 把集合中的元素,存储到数组中。

5)、遍历

public Iterator iterator():获取一个迭代器

3、iterator迭代器

public Iterator iterator(): 获取集合对应的迭代器,用来遍历集合中的元素的。

​ 1)、public boolean hasNext():如果仍有元素可以迭代,则返回 true。

​ 2)、public E next():返回迭代的下一个元素。

publicstaticvoidmain(String[] args) {

Collection list =newArrayList<>();

list.add;

list.add;

list.add;

list.add;

System.out.println;

Iterator iterable = list.iterator();while(iterable.hasNext{

System.out.println(iterable.next;

}

}

4、迭代器原理

美高梅棋牌游戏 2

5、迭代器-增强for

1)、增强for也叫:foreach循环,是一种for循环的新写法;

2)、使用增强for可以遍历数组、集合:

​ 1)、数组:

int[] arr = {1,2,3,4,5,6};for(int i = 0; i < arr.length ; i++){

int n = arr[i];

System.out.println;

}//增强forfor(int n:arr){//底层编译为:普通for循环 System.out.println;

}

​ 2)、集合:

ArrayList list =newArrayList<>();

//增强forfor(String str:list){

//底层编译为:迭代器System.out.println;

本文由美高梅游戏网站登录发布于美高梅棋牌游戏,转载请注明出处:C.编译运行都正常,Collection接口方法

您可能还会对下面的文章感兴趣: