Core Java(六)

 

集合框架 Collection 分支知识点 List

什么是 List? 列表接口，什么是列表接口？第一，对象可以重复，第二，对象有顺序的，这里说的有顺序指的是添加对象的顺序和输出的顺序是一样的

List 有两个分支： ArrayList 和 LinkedList

 

列表接口 List 分支知识点  ArrayList

什么是 ArrayList? 数组列表，常用遍历，一个一个的访问对象，优点就是遍历的效率高，访问快

 

import java.util.*;

public class TestArrayList {

       public static void test(){

              List l=new ArrayList();

              l.add(new Double(10));// 必须是对象

              l.add(new Double(20));

              l.add(new Double(5));

              l.add(new Double(20));// 可以重复，并且按添加的顺序输出

 

              System.out.println(l);

       }

       public static void main(String[] args) {

              test();

 

       }

 

}

 

ArrayList 分支知识点  Contins() 方法

什么是 contins 方法，有什么用呢？判断一个对象在数组列表中是不是存在，返回一个 boolean 类型的值

例 1 ：

import java.util.*;

public class TestArrayList2 {

       public static void test(){

              List l=new ArrayList();

              l.add("Hello");

              l.add("world");

              boolean isEmpay=l.contains("Hello");

              System.out.println(isEmpay);

       }

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

 

       }

 

}

例 2 ：

public class Teacher {

       private String name;

       private int age;

       public Teacher(String name, int age) {

              this.name = name;

              this.age = age;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public String toString() {

              // TODO Auto-generated method stub

              return name+age;

       }

      

}

 

import java.util.*;

 

public class TestTeacher {

// 程序目标：通过 ArrayList 将 4 个老师的信息打印出来

       public static void test(){

              List l=new ArrayList();

              Teacher t1=new Teacher("t1",20);

              Teacher t2=new Teacher("t2",25);

              Teacher t3=new Teacher("t3",28);

              Teacher t4=new Teacher("t4",18);

              l.add(t1);

              l.add(t2);

              l.add(t3);

              l.add(t4);

       //       System.out.println(l);

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

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

              }

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

 

 

 

 

例 3 ：

/* 程序目标： 1. 两种方式判断一个客户对象在数组列表中是不是存在

 *           2. 删除一个对象

 */

public class Customer {

       private String name;

       private String desc;

       public Customer(String name, String desc) {

              this.name = name;

              this.desc = desc;

       }

       public String getDesc() {

              return desc;

       }

       public void setDesc(String desc) {

              this.desc = desc;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public String toString() {

              return name+desc;

       }

       public boolean equals(Object arg0) {

              boolean rst=false;

              if(arg0 instanceof Customer){

                     Customer c=(Customer)arg0;

                     if(c.getName().equals(this.name)&&c.getDesc().equals(this.desc)){

                            rst=true;

                     }

              }

              return rst;

       }

      

      

}

 

man 方法类：

import java.util.*;

public class TestCustomer {

       public static void test(){

              List l=new ArrayList();

              Customer c1=new Customer("c1","common");

              Customer c2=new Customer("c2","vip");

              l.add(c1);

              l.add(c2);

//          boolean isExist=l.contains(c1);

              // 下面返回 false, 因为是自定义类，需要重写 equals 方法

              boolean isExist=l.contains(new Customer("c1","common"));

              System.out.println(isExist);

       }

      

       public static void test2(){

              List l=new ArrayList();

              Customer c1=new Customer("c1","common");

              Customer c2=new Customer("c2","vip");

              l.add(c1);

              l.add(c2);

              l.remove(0);

              System.out.println(l);

       }

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

              test2();

       }

 

}

 

集合框架 Collection 分支知识点 Map

什么是 Map?Map 就是映射，什么是映射呢？就是存储对象的一个键值对， key 指向 Value ，相当于一个学生的学号指向这个学生

 

映射 Map 分支知识点 HashMap

什么是 HashMap?hashMap 里面的 key 值是根据 hashcode 值来散列的，它的优点就是能够实现快速查找，是映射的一种，每组对象都是由 key 和 value 值存放的

 

例子：

 

 

/**

 * java 文件说明：

 * Customer.java----- 客户类

 * CustomerPK.java----- 指向客户对象的键值类

 */

 

// 程序目标： 1. 使用 HashMap 管理对象，并输出对象中的值 ,String 对象和自定义类对象的值

/*2.test2 ：使用 HashMap 管理对象，管理几个自定义类的对象，并打印出来，要求打印单独的一个对象的属性值

 * 3.test3: 让一个对象做为 key 值，然后通过这个对象显示另一个对象的信息

 */

package MY.collection.Map.HashMap;

//man 方法类

import java.util.*;

 

public class TestMap {

       //1

       public static void test(){

              Map map = new HashMap();

              map.put("s1","a");

              map.put("s2","b");

             

              map.put("s3",new Integer(5));

//          System.out.println(map);

              System.out.println(map.get("s1"));

       }

      

       public static void test2(){

              Map map=new HashMap();

              Customer c1=new Customer("c1","common");

              Customer c2=new Customer("c2","vip");

              map.put("s1",c1);

              map.put("s2",c2);

              System.out.println(map);

              System.out.println(map.get("s1"));

//          System.out.println(map.get(c1)); 这么写不行， map 调用的 get 方法是在 hashmap 中的， get 里面的参数是一个 key 值 , 不能传 value

              System.out.println(c1);

              Customer c3=(Customer)map.get("s2");

              System.out.println(c3);

       }

      

       public static void test3(){

              Map map=new HashMap();

              Customer c1=new Customer("c1","common");

              Customer c2=new Customer("c2","vip");

              CustomerPK id1=new CustomerPK("s1");

              CustomerPK id2=new CustomerPK("s2");

              map.put(id1,c1);

              map.put(id2,c2);

//          System.out.println(map);

//          System.out.println(map.get(id1));

             

              Customer c3=(Customer)map.get(id1);// 返回的是一个 object 引用类型 , 所以要强制转换

              System.out.println(c3);

              System.out.println(map.get(id1));// 这里的对象是一个 key,test2 中的是一个 value

           System.out.println(map.get(new CustomerPK("s1")));//new CustomerPK("s1") 会调用 equals 方法，比较这个对象和 id1 的那个对象的值是不是相同

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              //test();

              //test2();

              test3();

       }

 

}

 

集合框架 Collection 分支知识点 迭代器 iterator

什么是 iterator? 有什么用？什么情况下用？怎么用？

遍历容器中的对象，只向前一个一个访问对象，比如，你想认识一个朋友圈，这里有一个你认识的朋友，那么你可以通过你认识的这个朋友，通过他给你介绍认识这个朋友圈的人，你直接认识的这个朋友，可以把他看做是一个迭代器

 

/**

 * java 文件说明：

 * Student.java--- 学生类

 * 程序目标：

 * 1.test 方法：使用迭代器遍历容器中的对象，并显示出来，用 list 容器实现

 * 使用迭代器的 next 和 remove 方法，删除里面的对象

 * 2.test2 方法：造几个学生对象，添加到容器中 (List 和 Set 都可以 ), 通过迭代器和 for 循环打印出来

 * 3.test3 方法：使用 set 容器，得到迭代器，并将里面的对象显示出来

 * 4.test4 方法：自定义一个方法，这个方法使用迭代器将容器中的对象打印出来

 */

 

package MY.module06.collection.Iterator;

import java.util.*;

public class TestIterator {

       public static void test(){

              List l=new ArrayList();

              l.add("hello");

              l.add("world");

              l.add("!");

             

              Iterator it=l.iterator();// 先创建这个容器的迭代器， l.iterator() 得到该对象的迭代器

              while(it.hasNext()){// 如果有对象

                     System.out.println(it.next());// 返回迭代的下一个对象

              }

             

              List l1=new ArrayList();

              l1.add("hello");

              l1.add("world");

              l1.add("!");

              Iterator it2=l1.iterator();

              while(it2.hasNext()){

                     it2.next();

                     it2.remove();

              }

              System.out.println(l1);

       }

      

       public static void test2(){

              Student s1=new Student("s1",20);

              Student s2=new Student("s2",25);

              Student s3=new Student("s3",25);

              List l=new ArrayList();

              l.add(s1);

              l.add(s2);

              l.add(s3);

              System.out.println(l);

              Iterator it=l.iterator();

              System.out.println(l.get(0));

              System.out.println(s1);

              while(it.hasNext()){

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

                     Student stu=(Student)it.next();

                     System.out.println(stu);

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

              }

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

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

              }

       }

      

       public static void test3(){

              Set set=new HashSet();

              set.add("a");

              set.add("b");

              set.add("c");

              Iterator it=set.iterator();

              while(it.hasNext()){

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

              }

       }

       public static void test4(){

              Set set=new HashSet();

              set.add("a");

              set.add("b");

              set.add("c");

              List list=new ArrayList();

              list.add("d");

              list.add("e");

              list.add("f");

              print(set);

              print(list);

       }

      

       public static void print(Collection c){

              Iterator it=c.iterator();

              while(it.hasNext()){

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

              }

       }

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              //test();

              //test2();

              //test3();

              test4();

       }

 

}

 

Student.java 文件

package MY.module06.collection.Iterator;

 

public class Student {

       private String name;

       private int age;

       public Student(String name, int age) {

              this.name = name;

              this.age = age;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public String toString() {

              // TODO Auto-generated method stub

              return name+age;

       }

      

}

 

映射容器 Map 分支知识点 Vector

什么是 Vector? 可变长度的一个类似于数组的容器类，他的产生在 Collection 接口之前的，后来 sun 公司考虑到多态的特性，才硬把它继承了 Map ，性能不如 ArrayList 好，因为他会考虑线程的安全问题，附加一些操作

 

/**

 * 程序目标：

 * 1.test ：往 Vector 容器中添加几个对象，通过迭代器打印出来

 * 2.test2: 测试用于增加和读取对象的新旧方法

 */

package MY.module06.collection.old.oldlist.Vector;

import java.util.*;

public class TestVector {

       public static void test(){

              Vector v=new Vector();

              v.add("a");

              v.add("b");

              v.add("c");

             

              Iterator it=v.iterator();

              while(it.hasNext()){

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

              }

       }

       public static void test2(){

              Vector v=new Vector();

              v.add("a");

              v.addElement("b");

              Object o1=v.get(1);

              Object o2=v.elementAt(0);

              System.out.println(o1);

              System.out.println(o2);

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              //test();

              test2();

       }

 

}

 

映射容器 Map 分支知识点 Stack

什么是 Stack? 堆栈列表，后进先出，但是，因为它实现了 List 接口，可以使用 get 方法读取数据，这是 sun 公司的一个错误，所以，我们在用 stack 的时候，需要重新写一个新的 Stack

 

/**

 * 程序目标：

 * 1.test: 使用 stack 读写对象，并练习其中的方法的使用

 * 2.test2: 使用继承过来的 get 方法打印对象，这里说明了 sun 公司的错误

 */

package MY.module06.collection.old.oldlist.stack;

import java.util.*;

public class TestStack {

       public static void test(){

              Stack s=new Stack();

              s.push("a");

              s.push("b");

              s.push("c");

              System.out.println(s.pop());

              System.out.println(s);

              System.out.println(s.peek());

              System.out.println(s);

              System.out.println(s.capacity());

              System.out.println(s.isEmpty());

              System.out.println(s.pop());

              System.out.println(s.pop());

              System.out.println(s.isEmpty());

              System.out.println(s.capacity());

       }

       public static void test2(){

              Stack s=new Stack();

              s.add("a");

              s.add("b");

              s.add("c");

              System.out.println(s.get(2));// 违背了后进先出的规则，这是 sun 的一个错误

       }

 

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

       //       test();

              test2();

       }

 

}

 

为了避免这样的错误，我们需要定义一个新的 Stack 类

package MY.module06.collection.old.oldlist.stack;

import java.util.*;

public class MyStack {

    // 用于管理加入到 MyStack 中的对象

       private LinkedList list=new LinkedList();

       public void push(Object o){

              list.addFirst(o);

       }

       public Object peek(){

              return list.getFirst();

       }

       public Object pop(){

              return list.removeFirst();

       }

       public boolean isEmpty(){

              return list.isEmpty();

       }

       public int size(){

              return list.size();

       }

       public String toString() {

              // TODO Auto-generated method stub

              String x=null;

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

                     String ai;

                   ai=(String)list.get(i);

                   x=ai+x;

              }

              return x;

       }

}

 

/**

 * java 文件：

 * MyStack.java-- 堆栈容器类，重新定义了 push,peek,pop,isEmpty 等方法

 * 利用了链表类 LinkedList(List)

 * 程序目标：

 * 使用重新定义的堆栈容器，管理我们的对象

 */

package MY.module06.collection.old.oldlist.stack;

 

public class TestMyStack {

       public static void test(){

              MyStack ms=new MyStack();

              ms.push("a");

              ms.push("b");

              ms.push("c");

              System.out.println(ms.peek());

              System.out.println(ms.pop());

              System.out.println(ms);

             

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

              test();

       }

 

}

 

Collection 集合框架综合练习

/**

 * java 文件说明：

*Teacher.java-- 教师类

* TeacherComparator.java-- 比较器，排序用的

 * 程序目标：

 * 1.test: 用 ArrayList 管理对象，并输出对象信息

 * 2.test2: 将 ArrayList 转化为数组，对数组中 Teacher 按 age 进行排序并输出

 * 3.test3: 使用 Arrays.sort 对对象数组进行排序

 * 4.test4: 使用 Collections.sort 对对象数组进行排序 , 然后判断一个对象是否在 list 中

 * 并且使用 list.get 方法得到一个对象，打印出来，然后删除一个对象

 *

 */

package MY.module06.zuoye.collection;

import java.util.*;

public class TestTeacher {

       public static void test(){

              Teacher t1=new Teacher("liu",20);

              Teacher t2=new Teacher("li",25);

              Teacher t3=new Teacher("zhang",28);

              Teacher t4=new Teacher("t4",30);

              Teacher t5=new Teacher("t5",29);

              List l=new ArrayList();

              l.add(t1);

              l.add(t2);

              l.add(t3);

              l.add(t4);

              l.add(t5);

              System.out.println(l);

       }

      

       public static void test2(){

              Teacher t1=new Teacher("liu",20);

              Teacher t2=new Teacher("li",25);

              Teacher t3=new Teacher("zhang",28);

              Teacher t4=new Teacher("t4",30);

              Teacher t5=new Teacher("t5",29);

              List l=new ArrayList();

              l.add(t1);

              l.add(t2);

              l.add(t3);

              l.add(t4);

              l.add(t5);

              Object[] obj=l.toArray();

//          Teacher[] tc;

//          Teacher teacher2=(Teacher)teachers[j+1];// 不能这样做，因为是按值传递

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

//                 tc=new Teacher[obj.length];

//                 tc[i]=(Teacher)obj[i];

//          }

//          for(int i=0;i<tc.length;i++)

//                 for(int j=0;j<tc.length-i-1;j++)

//                        if(tc[j].getAge()>tc[j+1].getAge()){

//                               Teacher tz;

//                               tz=tc[j];

//                               tc[j]=tc[j+1];

//                               tc[j+1]=tz;

//                        }

              Object bmp=null;

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

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

                            if(((Teacher)obj[j]).getAge()>((Teacher)obj[j+1]).getAge()){

                                   bmp=obj[j];

                                   obj[j]=obj[j+1];

                                   obj[j+1]=bmp;

                            }

                     }

              }

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

                     System.out.println(obj[i]);

              }           

       }

       public static void test3(){

              Teacher t1=new Teacher("liu",20);

              Teacher t2=new Teacher("li",25);

              Teacher t3=new Teacher("zhang",28);

              Teacher t4=new Teacher("t4",30);

              Teacher t5=new Teacher("t5",29);

              List l=new ArrayList();

              l.add(t1);

              l.add(t2);

              l.add(t3);

              l.add(t4);

              l.add(t5);

//          用 Arrays.sort 排序， sort 对对象数组排序，所以要先转换为对象数组

              Object[] obj=l.toArray();

              // 此类包含用来操作数组（比如排序和搜索）的各种方法

              //       Arrays.sort(obj);// 这里需要实现排序规则的接口的方法

              Arrays.sort(obj,new TeacherComparator());

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

                     System.out.println(obj[i]);

              }    

       }

       public static void test4(){

              Teacher t1=new Teacher("liu",20);

              Teacher t2=new Teacher("li",25);

              Teacher t3=new Teacher("zhang",28);

              Teacher t4=new Teacher("t4",30);

              Teacher t5=new Teacher("t5",29);

              List l=new ArrayList();

              l.add(t1);

              l.add(t2);

              l.add(t3);

              l.add(t4);

              l.add(t5);

              Object[] obj=l.toArray();

              Collections.sort(l,new TeacherComparator());

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

                     System.out.println(obj[i]);

              }

              //System.out.println(l.contains(t5));

              System.out.println(l.contains(new Teacher("t5",29)));

              System.out.println(l.get(1));

              Teacher tc=(Teacher)l.get(1);

              System.out.println(tc);

              System.out.println(l.remove(1));

              System.out.println(l);

       }

       /**

        * @param args

        */

       public static void main(String[] args) {

              // TODO Auto-generated method stub

//          test();

              test2();

              test3();

              test4();

       }

 

}

 

Teacher.java-- 教师类

package MY.module06.zuoye.collection;

 

public class Teacher {

       private String name;

       private int age;

       public Teacher(String name, int age) {

              this.name = name;

              this.age = age;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public boolean equals(Object arg0) {

              boolean rst=false;

              if(arg0 instanceof Teacher){

                     Teacher tc=(Teacher)arg0;

                     if(tc.age==age&&tc.name.equals(name)){

                            rst=true;

                     }

              }

              return rst;

       }

       public int hashCode() {

              // TODO Auto-generated method stub

              return super.hashCode();

       }

       public String toString() {

              // TODO Auto-generated method stub

              return name+age;

       }

      

}

 

TeacherComparator.java-- 比较器，排序用的

import java.util.*;

 

public class TeacherComparator implements Comparator{

 

       public int compare(Object arg0, Object arg1) {

              // TODO Auto-generated method stub

              Teacher tc1=(Teacher)arg0;

              Teacher tc2=(Teacher)arg1;

              int rst=tc1.getAge()-tc2.getAge();

              return rst;

       }

 

}