Java基础2

文件结构

数组

Class5 / com.test1 / Demo5_1.java:

1. /*  
2.  * 功能：数组的必要性  
3.  */  
4.   
5. package com.test1;   
6.   
7. public class Demo5_1 {   
8.   
9.     /**  
10.      * @param args  
11.      */  
12.     public static void main(String[] args)    
13.     {   
14.         //定义一个可以存放六个float类型的数组   
15.         float[] arr=new float[6];   
16.         //给数组的各个元数赋值   
17.         arr[0]=3;   
18.         arr[1]=5;   
19.         arr[2]=1;   
20.         arr[3]=3.4f;   
21.         arr[4]=2;   
22.         arr[5]=50;   
23.         //算总体重   
24.         float all=0;   
25.         for(int i=0;i<6;i++)   
26.         {   
27.             all+=arr[i];   
28.         }   
29.         System.out.println("总体重是："+all);   
30.            
31.         //定义一个size=5的int数组   
32.         int[] arr1;   
33.         arr1=new int[5];   
34.            
35.         //如果你访问的数组范围大了   
36.         //arr[5]=10;   
37.         //如何知道数组的大小   
38.         System.out.println("数组arr1的大小："+arr1.length);   
39.            
40.         //滑板比赛   
41.         float arr2[]={3,6,7.1f,1.1f,3};   
42.         float all2=0;   
43.         for(int i=0;i<arr2.length;i++)   
44.         {   
45.             all2+=arr2[i];   
46.         }   
47.         System.out.println("平均时间："+(all2/arr2.length));   
48.     }   
49. }

Class5 / com.test5_2 / Demo5_2.java:

1. /*  
2.  * 功能：对象数组的使用  
3.  */  
4.   
5. package com.test1;   
6.   
7. import java.io.BufferedReader;   
8. import java.io.InputStreamReader;   
9.   
10. public class Demo5_2 {   
11.   
12.     /**  
13.      * @param args  
14.      */  
15.     public static void main(String[] args) throws Exception {   
16.         //定义一个可以存放四只狗的对象数组   
17.         Dog dogs[]=new Dog[4];   
18.         //创建一个能存放4只狗的Dog[]对象数组   
19.            
20.         /*  
21.         //给各个狗赋初值  
22.         dogs[0]=new Dog();//将dogs[0]存放创建一只狗的空间的地址  
23.         dogs[0].setName("花花");  
24.         dogs[0].setWeight(4.5f);  
25.         */  
26.         //从控制台输入各个狗的信息   
27.         InputStreamReader isr=new InputStreamReader(System.in);//IO流   
28.         BufferedReader br=new BufferedReader(isr);//将IO流转成Buffer流   
29.         for(int i=0;i<4;i++)   
30.         {   
31.             dogs[i]=new Dog();   
32.             System.out.println("请输入第"+(i+1)+"只狗的狗名：");   
33.             String name=br.readLine();//从控制台读取狗名   
34.             System.out.println("请输入第"+(i+1)+"只狗的体重:");   
35.             String s_weight=br.readLine();//从控制台读取体重   
36.             float weight=Float.parseFloat(s_weight);//将String转成float类型   
37.             //将名字赋给对象   
38.             dogs[i].setName(name);   
39.             //将体重赋给对象   
40.             dogs[i].setWeight(weight);   
41.                
42.         }   
43.         //计算总体重   
44.         float allWeight=0;   
45.         for(int i=0;i<4;i++)   
46.         {   
47.             allWeight+=dogs[i].getWeight();   
48.         }   
49.         //计算平均体重   
50.         float avgWeight=allWeight/dogs.length;   
51.         System.out.println("总体重="+allWeight+" 平均="+avgWeight);   
52.            
53.         //找出体重最大的狗   
54.         //假设第一只狗体重最大   
55.         float maxWeight=dogs[0].getWeight();   
56.         int maxIndex=0;   
57.         //依次比较狗的体重   
58.         for(int i=1;i<dogs.length;i++)   
59.         {   
60.             if(maxWeight<dogs[i].getWeight())   
61.             {   
62.                 //修改   
63.                 maxWeight=dogs[i].getWeight();   
64.                 maxIndex=i;   
65.             }   
66.         }   
67.         System.out.println("体重最大的狗是第"+(maxIndex+1)+"只狗，其体重是："  
68.                 +dogs[maxIndex].getWeight());   
69.            
70.         //输入狗的名字，查找它的体重   
71.         BufferedReader nam=new BufferedReader(isr);   
72.         System.out.println("请输入想要查找体重的狗的名字：");   
73.         String dogName=nam.readLine();   
74.         for(int i=1;i<dogs.length;i++)   
75.         {   
76.             if(dogName.equals(dogs[i].getName()))   
77.             {   
78.                 System.out.println(dogName+"的体重是："+dogs[i].getWeight());   
79.             }   
80.         }   
81.     }   
82.     /*  
83.      * 数组总结：  
84.      * 1.数组可存放同一类型数据  
85.      * 2.简单数据类型(int,float)数组，可直接赋值  
86.      * 3.对象数组定义后，赋值时需要再次为每个对象分配空间[即：new 对象]  
87.      * 4.数组大小 必须事先指定  
88.      * 5.数组名可以理解为执行数组首地址的引用  
89.      * 6.数组的下标是从0开始编号的  
90.      */  
91. }   
92.   
93. //定义一个狗类   
94. class Dog   
95. {   
96.     private String name;   
97.     private float weight;   
98.     public float getWeight() {   
99.         return weight;   
100.     }   
101.     public void setWeight(float weight) {   
102.         this.weight = weight;   
103.     }   
104.     public String getName() {   
105.         return name;   
106.     }   
107.     public void setName(String name) {   
108.         this.name = name;   
109.     }   
110. }  

Class5 / com.test1 / Demo5_5.java:

1. /*  
2.  * 功能：二维数组  
3.  */  
4.   
5. package com.test1;   
6.   
7. public class Demo5_5 {   
8.   
9.     /**  
10.      * @param args  
11.      */  
12.     public static void main(String[] args) {   
13.         int[][] a=new int[4][6];   
14.         a[1][2]=1;   
15.         a[2][1]=2;   
16.         a[2][3]=3;   
17.         //把图形输出   
18.         //行   
19.         for(int i=0;i<4;i++)   
20.         {   
21.             //列   
22.             for(int j=0;j<6;j++)   
23.             {   
24.                 System.out.print(a[i][j]+" ");   
25.             }   
26.             System.out.print("\n");   
27.         }   
28.     }   
29. }

排序与查找

排序介绍

冒泡排序

选择排序

快速排序

Class5 / com.test1 / Demo5_3.java:

1. /*  
2.  * 功能：演示各种排序法  
3.  */  
4.   
5. package com.test1;   
6. import java.util.Calendar;   
7.   
8. public class Demo5_3 {   
9.   
10.     /**  
11.      * @param args  
12.      */  
13.     public static void main(String[] args)    
14.     {   
15.         int len=10;   
16.         int[] arr=new int[len];   
17.         for(int i=0;i<len;i++)   
18.         {   
19.             //让程序随机产生一个1-10000的数   
20.             //int t=(int)(Math.random()*10000);   
21.             int t=(int)(Math.random()*100);   
22.             //Math.random()会随机产生一个0~1的数   
23.             arr[i]=t;   
24.         }   
25.         //int arr[]={1,6,0,-1,9,2,14,24,5};   
26.            
27.         //创建一个Bubble实例   
28.         Bubble bubble=new Bubble();   
29.         //在排序前打印系统时间   
30.         Calendar cal=Calendar.getInstance();//获得实例    
31.         System.out.print("冒泡排序前："+cal.getTime());   
32.            
33.         bubble.sort(arr);//排序，通过引用修改arr数组的顺序   
34.            
35.         cal=Calendar.getInstance();//重新获得实例    
36.         System.out.print("\n冒泡排序后："+cal.getTime());   
37.            
38.         //输出冒泡排序后的结果，打印有序数列   
39.         System.out.print("\n冒泡排序的结果：");   
40.         for(int i=0;i<arr.length;i++)   
41.         {   
42.             System.out.print(arr[i]+" ");   
43.         }   
44.            
45.         int a=12;   
46.         bubble.test(a);//简单数据类型传到函数中，它的改变不会导致外面的修改   
47.         System.out.println("\n\na="+a);   
48.            
49.         //-----------------------------------------------------   
50.         //创建一个Select实例   
51.         Select select=new Select();   
52.         //在排序前打印系统时间   
53.         cal=Calendar.getInstance();//获得实例    
54.         System.out.print("\n选择排序前："+cal.getTime());   
55.            
56.         //排序   
57.         select.sort(arr);   
58.            
59.         cal=Calendar.getInstance();//重新获得实例    
60.         System.out.print("\n选择排序后："+cal.getTime());   
61.            
62.         //输出选择排序后的结果，打印有序数列   
63.         System.out.print("\n选择排序的结果：");   
64.         for(int i=0;i<arr.length;i++)   
65.         {   
66.             System.out.print(arr[i]+" ");   
67.         }   
68.            
69.         //-------------------------------------------------   
70.         //创建一个InsertSort实例   
71.         InsertSort is=new InsertSort();   
72.         //在排序前打印系统时间   
73.         cal=Calendar.getInstance();//获得实例    
74.         System.out.print("\n\n插入排序前："+cal.getTime());   
75.            
76.         //排序   
77.         is.sort(arr);   
78.            
79.         cal=Calendar.getInstance();//重新获得实例    
80.         System.out.print("\n插入排序后："+cal.getTime());   
81.            
82.         //输出选择排序后的结果，打印有序数列   
83.         System.out.print("\n插入排序的结果：");   
84.         for(int i=0;i<arr.length;i++)   
85.         {   
86.             System.out.print(arr[i]+" ");   
87.         }   
88.            
89.         //-------------------------------------------------   
90.         //创建一个QuickSort实例   
91.         QuickSort qs=new QuickSort();   
92.         //在排序前打印系统时间   
93.         cal=Calendar.getInstance();//获得实例    
94.         System.out.print("\n\n快速排序前："+cal.getTime());   
95.            
96.         //排序   
97.         qs.sort(0,arr.length-1,arr);   
98.            
99.         cal=Calendar.getInstance();//重新获得实例    
100.         System.out.print("\n快速排序后："+cal.getTime());   
101.            
102.         //输出选择排序后的结果，打印有序数列   
103.         System.out.print("\n快速排序的结果：");   
104.         for(int i=0;i<arr.length;i++)   
105.         {   
106.             System.out.print(arr[i]+" ");   
107.         }   
108.     }   
109.   
110. }   
111.   
112. class Bubble   
113. {   
114.     //测试   
115.     public void test(int a)   
116.     {   
117.         a++;   
118.     }   
119.        
120.     //冒泡排序   
121.     public void sort(int arr[])   
122.     {   
123.         int temp=0;   
124.         //外层循环,决定一共走几趟   
125.         for(int i=0;i<arr.length-1;i++)   
126.         {   
127.             //内层循环，开始逐个比较，如果发现前一个数比后一个数大，则交换    
128.             for(int j=0;j<arr.length-1-i;j++)   
129.             {   
130.                 if(arr[j]>arr[j+1])   
131.                 {   
132.                     //换位   
133.                     temp=arr[j];   
134.                     arr[j]=arr[j+1];   
135.                     arr[j+1]=temp;   
136.                 }   
137.             }   
138.         }   
139.     }   
140. }   
141.   
142. class Select   
143. {   
144.     //选择排序   
145.     public void sort(int arr[])   
146.     {   
147.         int temp=0;//临时变量   
148.         for(int j=0;j<arr.length-1;j++)   
149.         //j<arr.length说明当只剩最后一个数没比较时，不必再比较了   
150.         {   
151.             //假设第j个数是最小的数   
152.             int min=arr[j];   
153.             //记录最小数的下标   
154.             int minIndex=j;   
155.             for(int k=j+1;k<arr.length;k++)   
156.             //k<arr.length说明只剩两个数未比较时，最后一个数要参与比较   
157.             {   
158.                 if(min>arr[k])   
159.                 {   
160.                     //修改最小   
161.                     min=arr[k];   
162.                     minIndex=k;   
163.                 }   
164.             }   
165.             //当退出内层for循环时，就找到这次的最小值   
166.             temp=arr[j];   
167.             arr[j]=arr[minIndex];   
168.             arr[minIndex]=temp;   
169.         }   
170.     }   
171. }   
172.   
173. //插入排序   
174. class InsertSort   
175. {   
176.     //插入排序方法   
177.     public void sort(int arr[])   
178.     {   
179.         for(int i=1;i<arr.length;i++)   
180.         {   
181.             int insertVal=arr[i];   
182.             //insertVal准备和前一个数比较   
183.             int index=i-1;   
184.             while(index>=0&&insertVal<arr[index])   
185.             {   
186.                 //将把arr[index]向后移动一位   
187.                 arr[index+1]=arr[index];   
188.                 //让index向前移动   
189.                 index--;   
190.             }   
191.             //将insertVal插入到行当 位置   
192.             arr[index+1]=insertVal;   
193.         }   
194.     }   
195. }   
196.   
197. //快速排序   
198. class QuickSort   
199. {   
200.     public void sort(int left,int right,int[] array)   
201.     {   
202.         int l=left;//左边   
203.         int r=right;//右边   
204.         int pivot=array[(left+right)/2];//中间的作为隔板数   
205.         int temp=0;   
206.         while(l<r)   
207.         {   
208.             while(array[l]<pivot) l++;   
209.             while(array[r]>pivot) r--;   
210.             if(l>=r) break;   
211.             temp=array[l];   
212.             array[l]=array[r];   
213.             array[r]=temp;   
214.                
215.             if(array[l]==pivot) --r;   
216.             if(array[r]==pivot) ++l;   
217.         }   
218.         if(l==r)   
219.         {   
220.             l++;   
221.             r--;   
222.         }   
223.         if(left<r) sort(left,r,array);   
224.         if(right>l) sort(l,right,array);            
225.     }   
226. }  

Class5 / com.test1 / Demo5_4.java:

1. /*  
2.  * 功能：二分查找  
3.  */  
4.   
5. package com.test1;   
6.   
7. public class Demo5_4 {   
8.   
9.     /**  
10.      * @param args  
11.      */  
12.     public static void main(String[] args) {   
13.         int arr[]={2,5,7,12,25};   
14.         BinaryFind bf=new BinaryFind();   
15.         bf.find(0, arr.length-1, 4, arr);   
16.     }   
17. }   
18.   
19. //二分查找   
20. class BinaryFind   
21. {   
22.     public void find(int leftIndex,int rightIndex,int val,int[] arr)   
23.     {   
24.         //首先找到中间的数   
25.         int midIndex=(rightIndex+leftIndex)/2;   
26.         int midVal=arr[midIndex];   
27.         if(rightIndex>=leftIndex)   
28.         {   
29.             //如果要找的数比midVal大   
30.             if(midVal>val)   
31.             {   
32.                 //在arr的左边数中找   
33.                 find(leftIndex,midIndex-1,val,arr);//递归   
34.             }   
35.             else if(midVal<val)   
36.             {   
37.                 //在arr的右边的数找   
38.                 find(midIndex+1,rightIndex,val,arr);//递归   
39.             }   
40.             else if(midVal==val)   
41.             {   
42.                 System.out.println("找到下标"+midIndex);   
43.             }   
44.         }   
45.         else  
46.         {   
47.             System.out.println("没有找到！");   
48.         }   
49.     }   
50. }

集合类及移位运算

Class7 / com.test1 / Demo7_1.java:

1. /*  
2.  * 功能：演示java集合的用法  
3.  */  
4.   
5. package com.test1;   
6. import java.util.*;   
7. public class Demo7_1 {   
8.   
9.     /**  
10.      * @param args  
11.      */  
12.     public static void main(String[] args) {   
13.         //定数组   
14.         //Clerk []clerks=new Clerk[???];   
15.         //定义ArrayList对象   
16.         ArrayList al=new ArrayList();   
17.         //显示大小   
18.         System.out.println("al大小："+al.size());   
19.         //向al中加入数据(类型是object)   
20.         //创建一个职员   
21.         Clerk clerk1=new Clerk("宋江",50,1000);   
22.         Clerk clerk2=new Clerk("吴用",45,1200);   
23.         Clerk clerk3=new Clerk("林冲",35,1300);   
24.         //将clerk1加入到al中   
25.         al.add(clerk1);   
26.         al.add(clerk2);   
27.         al.add(clerk3);   
28.         //显示大小   
29.         System.out.println("al大小："+al.size());   
30.         //如何访问al中对象（数据）   
31.         //访问第一个对象   
32.         Clerk temp=(Clerk)al.get(0);//因为get返回的是一个object   
33.         System.out.println("第一个名字是："+temp.getName());   
34.            
35.         //遍历al所有的对象   
36.         System.out.println("删除前");   
37.         for(int i=0;i<al.size();i++)   
38.         {   
39.             Clerk temp1=(Clerk)al.get(i);   
40.             System.out.println("名字是："+temp1.getName());   
41.         }   
42.         //从al中删除一个对象   
43.         al.remove(1);//删除吴用   
44.         System.out.println("=====删除吴用======");   
45.         //删除后   
46.         System.out.println("删除后");   
47.         for(int i=0;i<al.size();i++)   
48.         {   
49.             Clerk temp1=(Clerk)al.get(i);   
50.             System.out.println("名字是："+temp1.getName());   
51.         }   
52.     }   
53.   
54. }   
55.   
56. //定义一个员工类   
57. class Clerk   
58. {   
59.     private String name;   
60.     private int age;   
61.     private float sal;   
62.        
63.     public String getName() {   
64.         return name;   
65.     }   
66.   
67.     public void setName(String name) {   
68.         this.name = name;   
69.     }   
70.   
71.     public int getAge() {   
72.         return age;   
73.     }   
74.   
75.     public void setAge(int age) {   
76.         this.age = age;   
77.     }   
78.   
79.     public float getSal() {   
80.         return sal;   
81.     }   
82.   
83.     public void setSal(float sal) {   
84.         this.sal = sal;   
85.     }   
86.        
87.     public Clerk(String name,int age,float sal)   
88.     {   
89.         this.name=name;   
90.         this.age=age;   
91.         this.sal=sal;   
92.     }   
93. } 

Class7 / com.test1 / Demo7_2.java:

1. /*  
2.  * 功能：做一个公司职员薪水管理系统，要求完成如下功能 ：  
3.  * 1.当有新员工时，将该员工加入到管理系统  
4.  * 2.可以根据员工号，显示该员工的信息  
5.  * 3.可以显示所员工信息  
6.  * 4.可以修改员工薪水  
7.  * 5.当员工离职时，将该员工从管理系统中删除  
8.  * 6.可以按照薪水从低到高顺序排序  
9.  * 7.可以统计员工的平均工资和最低、最高工资  
10.  */  
11.   
12. package com.test1;   
13.   
14. import java.io.BufferedReader;   
15. import java.io.IOException;   
16. import java.io.InputStreamReader;   
17. import java.util.ArrayList;   
18.   
19. public class Demo7_2 {   
20.   
21.     /**  
22.      * @param args  
23.      * @throws IOException   
24.      */  
25.     public static void main(String[] args) throws IOException {   
26.         //演示   
27.         String a=new String("abc");   
28.         String b=new String("abc");   
29.         if(a==b)   
30.         {   
31.             System.out.println("== ok");   
32.         }   
33.         else if(a.equals(b))   
34.         {   
35.             System.out.println("equals ok");   
36.         }   
37.         else ;   
38.            
39.         //创建EmpManage对象   
40.         EmpManage em=new EmpManage();   
41.         //Emp emptemp=new Emp(null,null,0);   
42.         //定义一个BufferedReader流   
43.         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));   
44.         //作出一个简单菜单   
45.         while(true)   
46.         {   
47.             System.out.println("请选择你要进行的操作：");   
48.             System.out.println("1:表示添加一个雇员");   
49.             System.out.println("2:查找一个雇员");   
50.             System.out.println("3:显示所有雇员信息");   
51.             System.out.println("4:修改一个雇员工资");   
52.             System.out.println("5:删除一个雇员");   
53.             System.out.println("6：退出系统");   
54.                
55.             String operType=br.readLine();   
56.                
57.             if(operType.equals("1"))   
58.             {   
59.                 System.out.println("请输入编号：");   
60.                 String empNo=br.readLine();   
61.                 System.out.println("请输入名字：");   
62.                 String name=br.readLine();   
63.                 System.out.println("请输入工资：");   
64.                 float sal=Float.parseFloat(br.readLine());   
65.                    
66.                 Emp emp=new Emp(empNo,name,sal);   
67.                 Emp emptemp=em.addEmp(emp);   
68.                 //这里的"="相当于将返回的emp内存块直接复制一份给emptemp,即创建的同时   
69.                 //也就初始化了，所心不必再考的emptemp内部的属性是private，还是public,"="相当于直接复制   
70.                 System.out.println("=====添加"+emptemp.getName()+"成功！======\n");   
71.             }   
72.             else if(operType.equals("2"))   
73.             {   
74.                 System.out.println("请输入编号：");   
75.                 String empNo=br.readLine();   
76.                 //查找   
77.                 Emp emptemp=em.showInfo(empNo);   
78.                 System.out.println("=====查找"+empNo+"("+emptemp.getName()+")"+"成功！======\n");   
79.             }   
80.             else if(operType.equals("3"))   
81.             {   
82.                 //显示所有员工信息   
83.                 em.showAllInfo();   
84.                 System.out.println("=====已列出！======\n");   
85.             }   
86.             else if(operType.equals("4"))   
87.             {   
88.                 System.out.println("请输入编号：");   
89.                 String empNo=br.readLine();   
90.                 System.out.println("请输入工资：");   
91.                 float sal=Float.parseFloat(br.readLine());   
92.                 //修改   
93.                 Emp emptemp=em.updateSal(empNo, sal);   
94.                 System.out.println("=====修改"+empNo+"("+emptemp.getName()+")"+"工资成功！======\n");   
95.             }   
96.             else if(operType.equals("5"))   
97.             {   
98.                 System.out.println("请输入编号：");   
99.                 String empNo=br.readLine();   
100.                 //删除   
101.                 Emp emptemp=em.delEmp(empNo);   
102.                 System.out.println("=====删除"+empNo+"("+emptemp.getName()+")"+"成功！======\n");   
103.             }   
104.             else if(operType.equals("6"))   
105.             {   
106.                 //退出系统   
107.                 System.exit(0);//0表示正常退出JVM,非0表示异常退出JVM   
108.             }   
109.         }   
110.            
111.     }   
112.   
113. }   
114.   
115. //雇员类   
116. class Emp   
117. {   
118.     //学号   
119.     private String empNo;   
120.     private String name;   
121.     private float sal;   
122.     public String getEmpNo() {   
123.         return empNo;   
124.     }   
125.     public void setEmpNo(String empNo) {   
126.         this.empNo = empNo;   
127.     }   
128.     public String getName() {   
129.         return name;   
130.     }   
131.     public void setName(String name) {   
132.         this.name = name;   
133.     }   
134.     public float getSal() {   
135.         return sal;   
136.     }   
137.     public void setSal(float sal) {   
138.         this.sal = sal;   
139.     }   
140.        
141.     //构造函数   
142.     public Emp(String empNo,String name,float sal)   
143.     {   
144.         this.empNo=empNo;   
145.         this.name=name;   
146.         this.sal=sal;   
147.     }   
148. }   
149.   
150. //雇员管理类   
151. class EmpManage   
152. {   
153.     private ArrayList al=null;   
154.     public EmpManage()   
155.     {   
156.         al=new ArrayList();   
157.     }   
158.     //加入员工   
159.     public Emp addEmp(Emp emp)   
160.     {   
161.         if(al.add(emp))//如果添加成功   
162.             return emp;   
163.         else  
164.             return null;   
165.     }   
166.     //显示指定员工的相关信息   
167.     public Emp showInfo(String empNo)   
168.     {   
169.         //遍历整个ArrayList   
170.         for(int i=0;i<al.size();i++)   
171.         {   
172.             //取出Emp对象   
173.             Emp emp=(Emp)al.get(i);   
174.             //比较编号   
175.             if(emp.getEmpNo().equals(empNo));   
176.             {   
177.                 System.out.println("找到该员工，他的信息是：");   
178.                 System.out.println("编号="+emp.getEmpNo());   
179.                 System.out.println("名字="+emp.getName());   
180.                 System.out.println("工资="+emp.getSal());   
181.                    
182.                 return emp;   
183.             }   
184.         }   
185.         return null;   
186.     }   
187.     //显示所有员工的信息   
188.     public void showAllInfo()   
189.     {   
190.         //遍历整个ArrayList   
191.         for(int i=0;i<al.size();i++)   
192.         {   
193.             Emp emp=(Emp)al.get(i);   
194.             System.out.print("编号："+emp.getEmpNo()+" "  
195.                     +"名字："+emp.getName()+" "  
196.                     +"工资："+emp.getSal()+" "+"\n");   
197.         }   
198.     }   
199.     //修改工资   
200.     public Emp updateSal(String empNo,float newSal)   
201.     {   
202.         for(int i=0;i<al.size();i++)   
203.         {   
204.             Emp emp=(Emp)al.get(i);   
205.             if(emp.getEmpNo().equals(empNo))   
206.             {   
207.                 //修改薪水   
208.                 emp.setSal(newSal);   
209.                 return emp;   
210.             }   
211.         }   
212.         return null;   
213.     }   
214.     //删除员工   
215.     public Emp delEmp(String empNo)   
216.     {   
217.            
218.         for(int i=0;i<al.size();i++)   
219.         {   
220.             Emp emp=(Emp)al.get(i);   
221.             if(emp.getEmpNo().equals(empNo))   
222.             {   
223.                 al.remove(i);//按编号删除员工   
224.                 al.remove(emp);//按对象删除员工   
225.                 return emp;   
226.             }   
227.         }   
228.         return null;   
229.     }   
230. } 

Class7 / com.test1 / Demo7_3.java:

1. /*  
2.  * 功能：各种集合的使用  
3.  */  
4. package com.test1;   
5.   
6. import java.util.HashMap;   
7. import java.util.Hashtable;   
8. import java.util.Iterator;   
9. import java.util.LinkedList;   
10. import java.util.Stack;   
11. import java.util.Vector;   
12.   
13. public class Demo7_3 {   
14.   
15.     /**  
16.      * @param args  
17.      */  
18.     public static void main(String[] args) {   
19.         //LinkedList的用法   
20.         LinkedList ll=new LinkedList();   
21.         Emp emp1=new Emp("sa01","宋江",1.2f);   
22.         Emp emp2=new Emp("sa02","卢俊义",1.8f);   
23.         Emp emp3=new Emp("sa03","吴用",1.5f);   
24.         //表示把emp1加在链表的最前面   
25.         ll.addFirst(emp1);//向链表的当前结点的前面添加一个emp1结点   
26.         ll.addFirst(emp2);//前加   
27.         ll.addLast(emp3);//后加   
28.         for(int i=0;i<ll.size();i++)   
29.         {   
30.             System.out.println(((Emp)ll.get(i)).getName());   
31.         }   
32.         //------------------------------------------------------   
33.         //Vector的用法   
34.         //Vector与ArrayList的区别   
35.         //1.Vector有同步机制，ArrayList没有同步机制    
36.         //2.ArrayList缺省情况下自动增长原来的一倍，Vector是原来的50%增长   
37.         Vector vv=new Vector();   
38.         Emp emp4=new Emp("1","林冲",1.6f);   
39.         vv.add(emp4);   
40.         for(int i=0;i<vv.size();i++)   
41.         {   
42.             Emp emp=(Emp)vv.get(i);   
43.             System.out.println(emp.getName());   
44.         }   
45.         //------------------------------------------------------   
46.         //栈的用法   
47.         Stack stack=new Stack();   
48.         Emp emp5=new Emp("8","李逵",1.9f);   
49.         Emp emp6=new Emp("9","武松",1.7f);   
50.         Emp emp7=new Emp("5","公孙胜",1.7f);   
51.         stack.add(emp5);   
52.         stack.add(emp6);   
53.         stack.add(emp7);   
54.         for(int i=0;i<stack.size();i++)   
55.         {   
56.             Emp emp=(Emp)stack.get(i);   
57.             System.out.println(emp.getName());   
58.         }   
59.         //------------------------------------------------------   
60.         //HashMap的用法   
61.         //创建一个HashMap对象   
62.         HashMap hm=new HashMap();   
63.         Emp emp8=new Emp("s001","秦平",2.2f);   
64.         Emp emp9=new Emp("s002","花荣",2.3f);   
65.         Emp emp10=new Emp("s002","燕青",2.4f);   
66.         //将emp放入到   
67.         hm.put("s001", emp8);   
68.         hm.put("s002", emp9);   
69.         hm.put("s002", emp10);//出现键值相同时，会将emp10替换前面的   
70.         System.out.println(emp8.getName());   
71.         System.out.println(emp9.getName());   
72.            
73.         //如果要查找编号是s002   
74.         if(hm.containsKey("s002"))   
75.         {   
76.             System.out.println("-----------\n有该员工");   
77.             //如何取出,键<-->值   
78.             Emp emp=(Emp)hm.get("s002");   
79.             System.out.println("名字："+emp.getName());   
80.         }   
81.         else  
82.         {   
83.             System.out.println("-----------\n没有该员工");   
84.         }   
85.            
86.         //遍历HashMap中所有的key和value   
87.         Iterator it=hm.keySet().iterator();//迭代器   
88.         //hasNext返回一个boolean   
89.         System.out.println("-------开始遍历HashMap！------");   
90.         while(it.hasNext())//hasNext判断是否还有下一个   
91.         {   
92.             //取出Key   
93.             String key=it.next().toString();   
94.             //通过Key取出value   
95.             Emp emp=(Emp)hm.get(key);   
96.             System.out.println("名字："+emp.getName());   
97.         }   
98.         //HashMap在多线程并发操作时，因为没有同步机制作，   
99.         //可能会发生读脏数据，所以引入了安全的Hashtable   
100.         //------------------------------------------------------   
101.         //Hashtable的用法   
102.         Hashtable ht=new Hashtable();   
103.         /*  
104.         ht.put(null, null);  
105.         System.out.println("Hashtable null值测试"+ht.get(null));  
106.         //Hashtable不可以存放空值  
107.         */  
108.         HashMap hm2=new HashMap();   
109.         hm2.put(null, null);//HashMap可以存放空值   
110.         System.out.println("HashMap null值测试:"+hm2.get(null));   
111.         //Hashtable不可以存放空值   
112.            
113.         /*  
114.          * 集合总结：  
115.          * 1.如果要求线程安全，使用Vector,Hashtable  
116.          * 2.如果要求线程安全，使用ArrayList,LinkedList,HashMap  
117.          * 3.如果要求键值对，则使用HashMap,Hashtable  
118.          * 4.如果数据量很大，又要线程安全考虑Vector  
119.          */  
120.     }   
121. }

Class7 / com.test1 / Test1.java:

1. /*  
2.  * 功能：位运算和移位运算  
3.  */  
4.   
5. package com.test1;   
6.   
7. public class Test1 {   
8.   
9.     /**  
10.      * @param args  
11.      */  
12.     public static void main(String[] args) {   
13.         System.out.println("~2="+(~2));//取反   
14.         System.out.println("2&3="+(2&3));//与   
15.         System.out.println("2|3="+(2|3));//或   
16.         System.out.println("~-5="+(~-5));//取反   
17.         System.out.println("-3^3="+(-3^3));//异或   
18.   
19.         //算术右移：低位溢出，符号位不变，并用符号位补溢出的高位   
20.         //算术左移：符号位不变，低位补0   
21.         //逻辑右移:低位溢出，高位补零   
22.         System.out.println("1>>2="+(1>>2));   
23.         System.out.println("-1>>2="+(-1>>2));   
24.         System.out.println("1<<2="+(1<<2));   
25.         System.out.println("-1<<2="+(-1<<2));   
26.         System.out.println("3>>>2="+(3>>>2));//逻辑右移   
27.     }   
28. }