Java复习回顾---7月11日回顾练习

最新推荐文章于 2024-10-09 11:13:12 发布

weixin_30337251

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量193

点赞数

文章标签： java 数据结构与算法

原文链接：http://www.cnblogs.com/fangtingfei/p/11168201.html

版权

（集合类这部分的底层先不追究，等系统系统学完数据结构还会回来！！！这里先简单学习基本用法和操作吧，先赶进度。）

集合按存储结构可分两大类，单列集合Collection和双列集合Map

Collection：单列集合的根接口，他有两个重要的子接口List和Set，List的特点是元素有序，可重复。set的特点是元素无序且不可重复。List接口的主要实现类有ArraryList类和LinkList类，Set接口的主要实现类有HashSet和TreeSet。

Map：双列集合类的根接口，用于存储有键值映射关系的元素，每个元素对包含一对键值，在使用Map集合时可以通过指定的Key找到相应的Map接口的主要实现类有HashMap和TreeMap.

ArraryList类：

ArraryList集合是程序中最常见的集合，内部封装了一个长度可变的数组

 1 package cn.ftf.practice01;
 2 
 3 import java.util.ArrayList;
 4 
 5 /**
 6  * ArraryList集合是程序中最常见的集合，内部封装了一个长度可变的数组
 7  * @author 房廷飞
 8  *
 9  */
10 public class TestArraryList {
11     public static void main(String[] args) {
12         ArrayList<String> list=new ArrayList();    //创建集合对象并指定泛型为String，之后就只能添加String对象，否则报错
13         list.add("hello");
14         list.add("word");
15         list.add("!!!");
16         System.out.println(list.size());  //集合的长度，即元素的个数，注意不是“length”
17         System.out.println("第某个元素"+list.get(1));  //获取某个元素
18     }
19 
20 }

LinkedList类：

ArraryList查询效率高，但增删效率低。LinkedList类内部维护了一个双向链表，链表的每一个元素都通过引用的方法来记住他的前一个元素和后一个元素
，从而将所有元素连接起来，每插入一个新元素时，只需要修改元素之间的这种引用关系即可！增删效率比ArraryList高很多

 1 package cn.ftf.practice01;
 2 
 3 import java.util.LinkedList;
 4 
 5 /**
 6  * ArraryList查询效率高，但增删效率低。LinkedList类内部维护了一个双向链表，链表的每一个元素都通过引用的方法来记住他的前一个元素和后一个元素
 7  * ，从而将所有元素连接起来，每插入一个新元素时，只需要修改元素之间的这种引用关系即可！增删效率比ArraryList高得多
 8  * @author 房廷飞
 9  *
10  */
11 public class TestLinkedList {
12     public static void main(String[] args) {
13         LinkedList link=new LinkedList();  //创建集合
14         link.add("hello");    //将内容添加至列表
15         link.add("word");
16         link.add("!!!");
17         System.out.println(link.toString());  //打印列表中的元素
18         link.add(2,"students");  //向指定位置添加元素
19         link.addFirst("kaitou");  //向第一个位置添加元素
20         System.out.println(link);  //打印列表中的元素，不加toString也行
21         System.out.println(link.getFirst());  //获取列表第一个元素
22         link.remove(2);    //移除指定 位置元素
23         link.removeFirst();    //移除首位置元素
24         System.out.println(link);
25     }
26 
27 }
28 /*
29 打印结果：
30 [hello, word, !!!]
31 [kaitou, hello, word, students, !!!]
32 kaitou
33 [hello, students, !!!]
34 */

Iterator迭代器和foreach循环：

 1 package cn.ftf.practice01;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 /**
 7  * 迭代器Iterator对象和foreach循环
 8  * @author 房廷飞
 9  *
10  */
11 
12 public class TestIteratorAndForeach {
13     public static void main(String[] args) {
14         ArrayList<String> list=new ArrayList<String>();
15         list.add("hello");
16         list.add("word");
17         list.add("!!!");
18         list.add("房廷飞");
19         list.add("666");
20         list.remove("666");
21         System.out.println(list);
22         //int a=Integer.parseInt(list.get(4));
23         //System.out.println(a);
24         
25         //迭代器的使用方法
26         Iterator<String> it=list.iterator();    //创建一个迭代器实例对象
27         while(it.hasNext()) {    //判断是否有下一个值
28             Object ob=it.next();    //挨个取出
29             System.out.println(ob);
30         }
31         
32         //foreach循环是一种更加简洁的for循环，用于遍历数组或集合中的元素
33         
34         //foreach循环的用法
35         for(Object obj:list) {
36             System.out.println(obj);
37         }
38         
39         //foreach循环只能遍历元素，不能修改集合内容，修改可用Iterator
40         Iterator<String> iter=list.iterator();    
41         while(it.hasNext()) {
42             Object obje=iter.next();
43             if(iter.next()=="word") {
44                 iter.remove();  //一种移除办法，或直接Break跳出循环。而不能list.remove("word"),会使迭代器迭代次序混乱而报错
45             }
46         }
47         
48     }
49 
50 }

ArrayList类的一个小综合运用，KTV点歌系统小程序，涉及到集合的增删改查功能。LinkedList类也差不多的。

 1 package cn.ftf.KTV;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Scanner;
 5 
 6 public class KTVByArraryList {
 7     public static void main(String[] args) {
 8         ArrayList<String> list=new ArrayList();
 9         list.add("平凡之路");
10         list.add("海阔天空");
11         list.add("沙漠骆驼");
12         list.add("光辉岁月");
13         System.out.println(list);
14         
15         System.out.println("请选择要执行的操作：");
16         System.out.println("1,添加歌曲"+"\n"+"2,删除歌曲"+"\n"+"3，前移一位，0退出");
17         int a = new Scanner(System.in).nextInt();
18         switch (a) {
19         case 1:
20             addMusic(list);
21             break;
22         case 2:
23             removeMusic(list);
24             break;
25         case 3:
26             moveMusic(list);
27             break;
28         case 0:
29             System.exit(0);
30             break;
31         default:
32             System.out.println("输入错误！！！!!!");
33             main(args);
34             break;
35         }
36     }
37     private static void addMusic(ArrayList<String> list) {
38         System.out.println("添加啥：");
39         String name=new Scanner(System.in).nextLine();
40         list.add(name);
41         System.out.println(list);
42     }
43     private static void removeMusic(ArrayList<String> list) {
44         System.out.println("移除啥：");
45         String name=new Scanner(System.in).nextLine();
46         list.remove(name);
47         System.out.println(list);
48 
49     }
50     private static void moveMusic(ArrayList<String> list) {
51         System.out.println("前移一位啥：");
52         String name=new Scanner(System.in).nextLine();
53         int position=list.indexOf(name);
54         if(position<0) {
55             System.out.println("没有！！！");
56             
57         }else if(position==0) {
58             System.out.println("已经在第一位！");
59             
60         }else {
61             list.remove(name);
62             list.add(position-1, name);
63         }
64         System.out.println(list);
65 
66     }
67 
68 }

HashSet类：

* Set接口中元素无序，并以某种规则保证存入的元素不会重复
* Set接口主要有两个实现类，分别是HashSet和TreeSet，HashSet根据对象的Hash值来确定元素在集合中的存储位置，因此具有良好的存取和查找功能。TreeSet则是以二叉树的方式来存储元素，他可以实现对集合中元素进行排序，接下来对HashSet进行探讨
* 当向HashSet集合中添加一个对象时，首先会调用对象的Hash Code来计算该对象的存储位置，如果此时Hash值相同，再调用对象的equal(0方法来确保该位置没有重复元素。
* Set集合的存取元素方法和List类相同

 1 package cn.ftf.practice01;
 2 
 3 import java.util.HashSet;
 4 import java.util.Iterator;
 5 
 6 /**
 7  * Set接口中元素无序，并以某种规则保证存入的元素不会重复
 8  * Set接口主要有两个实现类，分别是HashSet和TreeSet，HashSet根据对象的Hash值来确定元素在集合中的存储位置，因此具有良好的存取和查找功能。TreeSet则是以二叉树的方式来存储元素，他可以实现对集合中元素进行排序，接下来对HashSet进行探讨
 9  * 当向HashSet集合中添加一个对象时，首先会调用对象的Hash Code来计算该对象的存储位置，如果此时Hash值相同，再调用对象的equal(0方法来确保该位置没有重复元素。
10  * Set集合的存取元素方法和List类相同
11  * @author 房廷飞
12  *
13  */
14 public class TestHashSet {
15     public static void main(String[] args) {
16         HashSet<String> ha=new HashSet();    //实例化一个HashSet对象
17         ha.add("hello");
18         ha.add("word");
19         ha.add("hello");
20         ha.add("!!!");
21         
22         Iterator<String> it=ha.iterator();
23         while(it.hasNext()) {
24             Object obj=it.next();
25             System.out.println(obj);
26         }
27         
28         
29         //实例对象写入集合
30         Student st1=new Student(1, "房廷飞");
31         Student st2=new Student(2, "步嘉驰");
32         Student st3=new Student(1, "梅鹏欣");
33         Student st4=new Student(3, "房廷飞");
34         HashSet<Student>has=new HashSet();
35         has.add(st4);
36         has.add(st3);
37         has.add(st2);
38         has.add(st1);
39         System.out.println(has);
40         
41         
42         
43     }
44 
45 }
46 class Student{
47     int id;
48     String name;
49     public Student(int id, String name) {
50         super();
51         this.id = id;
52         this.name = name;
53     }
54     
55     //自动生成toString方法
56     @Override
57     public String toString() {
58         return "student [id=" + id + ", name=" + name + "]";
59     }
60     
61     //自动生成重写HashCode方法和equal方法
62     @Override
63     public int hashCode() {
64         final int prime = 31;
65         int result = 1;
66         result = prime * result + id;
67         return result;
68     }
69     @Override
70     public boolean equals(Object obj) {
71         if (this == obj)
72             return true;
73         if (obj == null)
74             return false;
75         if (getClass() != obj.getClass())
76             return false;
77         Student other = (Student) obj;
78         if (id != other.id)
79             return false;
80         return true;
81     }
82     
83     
84     
85 }
结果：
!!!
hello
word
[student [id=1, name=梅鹏欣], student [id=2, name=步嘉驰], student [id=3, name=房廷飞]]

Map接口是一种双列集合，它的每个元素都包含一个键值对（key和value）键和值是一种映射关系。

HashMap是Map接口的一个实现类，用于存储键值映射关系，必须保证不能出现重复的键，否则后键的value覆盖前键的value

 1 package cn.ftf.practice01;
 2 
 3 
 4 import java.util.HashMap;
 5 import java.util.Iterator;
 6 import java.util.Map;
 7 import java.util.Set;
 8 
 9 /**
10  * HashMap的简单使用
11  * @author 房廷飞
12  *
13  */
14 public class TestHashMap {
15     public static void main(String[] args) {
16         
17         Student2 s1=new Student2(01, "房廷飞",20);
18         Student2 s2=new Student2(02, "房飞",10);
19         Student2 s3=new Student2(03, "房廷",240);
20 
21 
22         Map m1=new HashMap<Integer,Student2>();
23         m1.put(1, s1);  //放入键值对
24         m1.put(2, s2);
25         m1.put(1, s3);  //键不能重复，否则替换旧值
26         System.out.println(m1);
27         System.out.println("获取值："+m1.get(2));
28         
29         //遍历Map中的元素
30         
31         Set keySet=m1.keySet();    //获取键的集合
32         Iterator<Integer> it=keySet.iterator();
33         while(it.hasNext()) {
34             Object key=it.next();
35             Object value=m1.get(key);
36             System.out.println(value);    //遍历起来顺序会不一致，如果要顺序一致，需要使用LinkHashMap类
37         }
38     }
39 
40 }
41 class Student2{
42     private int id;
43     private String name;
44     private int age;
45     public Student2(int id, String name, int age) {
46         super();
47         this.id = id;
48         this.name = name;
49         this.age = age;
50     }
51     public int getId() {
52         return id;
53     }
54     public void setId(int id) {
55         this.id = id;
56     }
57     public String getName() {
58         return name;
59     }
60     public void setName(String name) {
61         this.name = name;
62     }
63     public int getAge() {
64         return age;
65     }
66     public void setAge(int age) {
67         this.age = age;
68     }
69     @Override
70         public String toString() {
71             // TODO Auto-generated method stub
72             return "id:"+id+",name:"+name;
73         }
74     
75 }