Java笔记2(数组、排序、查找、集合类、移位)

文件结构

Class5 / com.test1 / Demo5_1.java: 
数组 

/*   
 * 功能：数组的必要性   
 */   
   
package com.test1;    
   
public class Demo5_1 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args)     
    {    
        //定义一个可以存放六个float类型的数组    
        float[] arr=new float[6];    
        //给数组的各个元数赋值    
        arr[0]=3;    
        arr[1]=5;    
        arr[2]=1;    
        arr[3]=3.4f;    
        arr[4]=2;    
        arr[5]=50;    
        //算总体重    
        float all=0;    
        for(int i=0;i<6;i++)    
        {    
            all+=arr[i];    
        }    
        System.out.println("总体重是："+all);    
            
        //定义一个size=5的int数组    
        int[] arr1;    
        arr1=new int[5];    
            
        //如果你访问的数组范围大了    
        //arr[5]=10;    
        //如何知道数组的大小    
        System.out.println("数组arr1的大小："+arr1.length);    
            
        //滑板比赛    
        float arr2[]={3,6,7.1f,1.1f,3};    
        float all2=0;    
        for(int i=0;i<arr2.length;i++)    
        {    
            all2+=arr2[i];    
        }    
        System.out.println("平均时间："+(all2/arr2.length));    
    }    
} 
Class5 / com.test5_2 / Demo5_2.java: 

/*   
 * 功能：对象数组的使用   
 */   
   
package com.test1;    
   
import java.io.BufferedReader;    
import java.io.InputStreamReader;    
   
public class Demo5_2 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) throws Exception {    
        //定义一个可以存放四只狗的对象数组    
        Dog dogs[]=new Dog[4];    
        //创建一个能存放4只狗的Dog[]对象数组    
            
        /*   
        //给各个狗赋初值   
        dogs[0]=new Dog();//将dogs[0]存放创建一只狗的空间的地址   
        dogs[0].setName("花花");   
        dogs[0].setWeight(4.5f);   
        */   
        //从控制台输入各个狗的信息    
        InputStreamReader isr=new InputStreamReader(System.in);//IO流    
        BufferedReader br=new BufferedReader(isr);//将IO流转成Buffer流    
        for(int i=0;i<4;i++)    
        {    
            dogs[i]=new Dog();    
            System.out.println("请输入第"+(i+1)+"只狗的狗名：");    
            String name=br.readLine();//从控制台读取狗名    
            System.out.println("请输入第"+(i+1)+"只狗的体重:");    
            String s_weight=br.readLine();//从控制台读取体重    
            float weight=Float.parseFloat(s_weight);//将String转成float类型    
            //将名字赋给对象    
            dogs[i].setName(name);    
            //将体重赋给对象    
            dogs[i].setWeight(weight);    
                
        }    
        //计算总体重    
        float allWeight=0;    
        for(int i=0;i<4;i++)    
        {    
            allWeight+=dogs[i].getWeight();    
        }    
        //计算平均体重    
        float avgWeight=allWeight/dogs.length;    
        System.out.println("总体重="+allWeight+" 平均="+avgWeight);    
            
        //找出体重最大的狗    
        //假设第一只狗体重最大    
        float maxWeight=dogs[0].getWeight();    
        int maxIndex=0;    
        //依次比较狗的体重    
        for(int i=1;i<dogs.length;i++)    
        {    
            if(maxWeight<dogs[i].getWeight())    
            {    
                //修改    
                maxWeight=dogs[i].getWeight();    
                maxIndex=i;    
            }    
        }    
        System.out.println("体重最大的狗是第"+(maxIndex+1)+"只狗，其体重是："   
                +dogs[maxIndex].getWeight());    
            
        //输入狗的名字，查找它的体重    
        BufferedReader nam=new BufferedReader(isr);    
        System.out.println("请输入想要查找体重的狗的名字：");    
        String dogName=nam.readLine();    
        for(int i=1;i<dogs.length;i++)    
        {    
            if(dogName.equals(dogs[i].getName()))    
            {    
                System.out.println(dogName+"的体重是："+dogs[i].getWeight());    
            }    
        }    
    }    
    /*   
     * 数组总结：   
     * 1.数组可存放同一类型数据   
     * 2.简单数据类型(int,float)数组，可直接赋值   
     * 3.对象数组定义后，赋值时需要再次为每个对象分配空间[即：new 对象]   
     * 4.数组大小 必须事先指定   
     * 5.数组名可以理解为执行数组首地址的引用   
     * 6.数组的下标是从0开始编号的   
     */   
}    
   
//定义一个狗类    
class Dog    
{    
    private String name;    
    private float weight;    
    public float getWeight() {    
        return weight;    
    }    
    public void setWeight(float weight) {    
        this.weight = weight;    
    }    
    public String getName() {    
        return name;    
    }    
    public void setName(String name) {    
        this.name = name;    
    }    
}   
Class5 / com.test1 / Demo5_5.java: 

/*   
 * 功能：二维数组   
 */   
   
package com.test1;    
   
public class Demo5_5 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        int[][] a=new int[4][6];    
        a[1][2]=1;    
        a[2][1]=2;    
        a[2][3]=3;    
        //把图形输出    
        //行    
        for(int i=0;i<4;i++)    
        {    
            //列    
            for(int j=0;j<6;j++)    
            {    
                System.out.print(a[i][j]+" ");    
            }    
            System.out.print("\n");    
        }    
    }    
} 

排序与查找

排序介绍


冒泡排序

选择排序


快速排序

Class5 / com.test1 / Demo5_3.java: 

/*   
 * 功能：演示各种排序法   
 */   
   
package com.test1;    
import java.util.Calendar;    
   
public class Demo5_3 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args)     
    {    
        int len=10;    
        int[] arr=new int[len];    
        for(int i=0;i<len;i++)    
        {    
            //让程序随机产生一个1-10000的数    
            //int t=(int)(Math.random()*10000);    
            int t=(int)(Math.random()*100);    
            //Math.random()会随机产生一个0~1的数    
            arr[i]=t;    
        }    
        //int arr[]={1,6,0,-1,9,2,14,24,5};    
            
        //创建一个Bubble实例    
        Bubble bubble=new Bubble();    
        //在排序前打印系统时间    
        Calendar cal=Calendar.getInstance();//获得实例     
        System.out.print("冒泡排序前："+cal.getTime());    
            
        bubble.sort(arr);//排序，通过引用修改arr数组的顺序    
            
        cal=Calendar.getInstance();//重新获得实例     
        System.out.print("\n冒泡排序后："+cal.getTime());    
            
        //输出冒泡排序后的结果，打印有序数列    
        System.out.print("\n冒泡排序的结果：");    
        for(int i=0;i<arr.length;i++)    
        {    
            System.out.print(arr[i]+" ");    
        }    
            
        int a=12;    
        bubble.test(a);//简单数据类型传到函数中，它的改变不会导致外面的修改    
        System.out.println("\n\na="+a);    
            
        //-----------------------------------------------------    
        //创建一个Select实例    
        Select select=new Select();    
        //在排序前打印系统时间    
        cal=Calendar.getInstance();//获得实例     
        System.out.print("\n选择排序前："+cal.getTime());    
            
        //排序    
        select.sort(arr);    
            
        cal=Calendar.getInstance();//重新获得实例     
        System.out.print("\n选择排序后："+cal.getTime());    
            
        //输出选择排序后的结果，打印有序数列    
        System.out.print("\n选择排序的结果：");    
        for(int i=0;i<arr.length;i++)    
        {    
            System.out.print(arr[i]+" ");    
        }    
            
        //-------------------------------------------------    
        //创建一个InsertSort实例    
        InsertSort is=new InsertSort();    
        //在排序前打印系统时间    
        cal=Calendar.getInstance();//获得实例     
        System.out.print("\n\n插入排序前："+cal.getTime());    
            
        //排序    
        is.sort(arr);    
            
        cal=Calendar.getInstance();//重新获得实例     
        System.out.print("\n插入排序后："+cal.getTime());    
            
        //输出选择排序后的结果，打印有序数列    
        System.out.print("\n插入排序的结果：");    
        for(int i=0;i<arr.length;i++)    
        {    
            System.out.print(arr[i]+" ");    
        }    
            
        //-------------------------------------------------    
        //创建一个QuickSort实例    
        QuickSort qs=new QuickSort();    
        //在排序前打印系统时间    
        cal=Calendar.getInstance();//获得实例     
        System.out.print("\n\n快速排序前："+cal.getTime());    
            
        //排序    
        qs.sort(0,arr.length-1,arr);    
            
        cal=Calendar.getInstance();//重新获得实例     
        System.out.print("\n快速排序后："+cal.getTime());    
            
        //输出选择排序后的结果，打印有序数列    
        System.out.print("\n快速排序的结果：");    
        for(int i=0;i<arr.length;i++)    
        {    
            System.out.print(arr[i]+" ");    
        }    
    }    
   
}    
   
class Bubble    
{    
    //测试    
    public void test(int a)    
    {    
        a++;    
    }    
        
    //冒泡排序    
    public void sort(int arr[])    
    {    
        int temp=0;    
        //外层循环,决定一共走几趟    
        for(int i=0;i<arr.length-1;i++)    
        {    
            //内层循环，开始逐个比较，如果发现前一个数比后一个数大，则交换     
            for(int j=0;j<arr.length-1-i;j++)    
            {    
                if(arr[j]>arr[j+1])    
                {    
                    //换位    
                    temp=arr[j];    
                    arr[j]=arr[j+1];    
                    arr[j+1]=temp;    
                }    
            }    
        }    
    }    
}    
   
class Select    
{    
    //选择排序    
    public void sort(int arr[])    
    {    
        int temp=0;//临时变量    
        for(int j=0;j<arr.length-1;j++)    
        //j<arr.length说明当只剩最后一个数没比较时，不必再比较了    
        {    
            //假设第j个数是最小的数    
            int min=arr[j];    
            //记录最小数的下标    
            int minIndex=j;    
            for(int k=j+1;k<arr.length;k++)    
            //k<arr.length说明只剩两个数未比较时，最后一个数要参与比较    
            {    
                if(min>arr[k])    
                {    
                    //修改最小    
                    min=arr[k];    
                    minIndex=k;    
                }    
            }    
            //当退出内层for循环时，就找到这次的最小值    
            temp=arr[j];    
            arr[j]=arr[minIndex];    
            arr[minIndex]=temp;    
        }    
    }    
}    
   
//插入排序    
class InsertSort    
{    
    //插入排序方法    
    public void sort(int arr[])    
    {    
        for(int i=1;i<arr.length;i++)    
        {    
            int insertVal=arr[i];    
            //insertVal准备和前一个数比较    
            int index=i-1;    
            while(index>=0&&insertVal<arr[index])    
            {    
                //将把arr[index]向后移动一位    
                arr[index+1]=arr[index];    
                //让index向前移动    
                index--;    
            }    
            //将insertVal插入到行当 位置    
            arr[index+1]=insertVal;    
        }    
    }    
}    
   
//快速排序    
class QuickSort    
{    
    public void sort(int left,int right,int[] array)    
    {    
        int l=left;//左边    
        int r=right;//右边    
        int pivot=array[(left+right)/2];//中间的作为隔板数    
        int temp=0;    
        while(l<r)    
        {    
            while(array[l]<pivot) l++;    
            while(array[r]>pivot) r--;    
            if(l>=r) break;    
            temp=array[l];    
            array[l]=array[r];    
            array[r]=temp;    
                
            if(array[l]==pivot) --r;    
            if(array[r]==pivot) ++l;    
        }    
        if(l==r)    
        {    
            l++;    
            r--;    
        }    
        if(left<r) sort(left,r,array);    
        if(right>l) sort(l,right,array);             
    }    
}   
Class5 / com.test1 / Demo5_4.java: 

/*   
 * 功能：二分查找   
 */   
   
package com.test1;    
   
public class Demo5_4 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        int arr[]={2,5,7,12,25};    
        BinaryFind bf=new BinaryFind();    
        bf.find(0, arr.length-1, 4, arr);    
    }    
}    
   
//二分查找    
class BinaryFind    
{    
    public void find(int leftIndex,int rightIndex,int val,int[] arr)    
    {    
        //首先找到中间的数    
        int midIndex=(rightIndex+leftIndex)/2;    
        int midVal=arr[midIndex];    
        if(rightIndex>=leftIndex)    
        {    
            //如果要找的数比midVal大    
            if(midVal>val)    
            {    
                //在arr的左边数中找    
                find(leftIndex,midIndex-1,val,arr);//递归    
            }    
            else if(midVal<val)    
            {    
                //在arr的右边的数找    
                find(midIndex+1,rightIndex,val,arr);//递归    
            }    
            else if(midVal==val)    
            {    
                System.out.println("找到下标"+midIndex);    
            }    
        }    
        else   
        {    
            System.out.println("没有找到！");    
        }    
    }    
} 

集合类及移位运算

Class7 / com.test1 / Demo7_1.java: 

/*   
 * 功能：演示java集合的用法   
 */   
   
package com.test1;    
import java.util.*;    
public class Demo7_1 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //定数组    
        //Clerk []clerks=new Clerk[???];    
        //定义ArrayList对象    
        ArrayList al=new ArrayList();    
        //显示大小    
        System.out.println("al大小："+al.size());    
        //向al中加入数据(类型是object)    
        //创建一个职员    
        Clerk clerk1=new Clerk("宋江",50,1000);    
        Clerk clerk2=new Clerk("吴用",45,1200);    
        Clerk clerk3=new Clerk("林冲",35,1300);    
        //将clerk1加入到al中    
        al.add(clerk1);    
        al.add(clerk2);    
        al.add(clerk3);    
        //显示大小    
        System.out.println("al大小："+al.size());    
        //如何访问al中对象（数据）    
        //访问第一个对象    
        Clerk temp=(Clerk)al.get(0);//因为get返回的是一个object    
        System.out.println("第一个名字是："+temp.getName());    
            
        //遍历al所有的对象    
        System.out.println("删除前");    
        for(int i=0;i<al.size();i++)    
        {    
            Clerk temp1=(Clerk)al.get(i);    
            System.out.println("名字是："+temp1.getName());    
        }    
        //从al中删除一个对象    
        al.remove(1);//删除吴用    
        System.out.println("=====删除吴用======");    
        //删除后    
        System.out.println("删除后");    
        for(int i=0;i<al.size();i++)    
        {    
            Clerk temp1=(Clerk)al.get(i);    
            System.out.println("名字是："+temp1.getName());    
        }    
    }    
   
}    
   
//定义一个员工类    
class Clerk    
{    
    private String name;    
    private int age;    
    private float sal;    
        
    public String getName() {    
        return name;    
    }    
   
    public void setName(String name) {    
        this.name = name;    
    }    
   
    public int getAge() {    
        return age;    
    }    
   
    public void setAge(int age) {    
        this.age = age;    
    }    
   
    public float getSal() {    
        return sal;    
    }    
   
    public void setSal(float sal) {    
        this.sal = sal;    
    }    
        
    public Clerk(String name,int age,float sal)    
    {    
        this.name=name;    
        this.age=age;    
        this.sal=sal;    
    }    
}  
Class7 / com.test1 / Demo7_2.java: 

/*   
 * 功能：做一个公司职员薪水管理系统，要求完成如下功能 ：   
 * 1.当有新员工时，将该员工加入到管理系统   
 * 2.可以根据员工号，显示该员工的信息   
 * 3.可以显示所员工信息   
 * 4.可以修改员工薪水   
 * 5.当员工离职时，将该员工从管理系统中删除   
 * 6.可以按照薪水从低到高顺序排序   
 * 7.可以统计员工的平均工资和最低、最高工资   
 */   
   
package com.test1;    
   
import java.io.BufferedReader;    
import java.io.IOException;    
import java.io.InputStreamReader;    
import java.util.ArrayList;    
   
public class Demo7_2 {    
   
    /**   
     * @param args   
     * @throws IOException    
     */   
    public static void main(String[] args) throws IOException {    
        //演示    
        String a=new String("abc");    
        String b=new String("abc");    
        if(a==b)    
        {    
            System.out.println("== ok");    
        }    
        else if(a.equals(b))    
        {    
            System.out.println("equals ok");    
        }    
        else ;    
            
        //创建EmpManage对象    
        EmpManage em=new EmpManage();    
        //Emp emptemp=new Emp(null,null,0);    
        //定义一个BufferedReader流    
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));    
        //作出一个简单菜单    
        while(true)    
        {    
            System.out.println("请选择你要进行的操作：");    
            System.out.println("1:表示添加一个雇员");    
            System.out.println("2:查找一个雇员");    
            System.out.println("3:显示所有雇员信息");    
            System.out.println("4:修改一个雇员工资");    
            System.out.println("5:删除一个雇员");    
            System.out.println("6：退出系统");    
                
            String operType=br.readLine();    
                
            if(operType.equals("1"))    
            {    
                System.out.println("请输入编号：");    
                String empNo=br.readLine();    
                System.out.println("请输入名字：");    
                String name=br.readLine();    
                System.out.println("请输入工资：");    
                float sal=Float.parseFloat(br.readLine());    
                    
                Emp emp=new Emp(empNo,name,sal);    
                Emp emptemp=em.addEmp(emp);    
                //这里的"="相当于将返回的emp内存块直接复制一份给emptemp,即创建的同时    
                //也就初始化了，所心不必再考的emptemp内部的属性是private，还是public,"="相当于直接复制    
                System.out.println("=====添加"+emptemp.getName()+"成功！======\n");    
            }    
            else if(operType.equals("2"))    
            {    
                System.out.println("请输入编号：");    
                String empNo=br.readLine();    
                //查找    
                Emp emptemp=em.showInfo(empNo);    
                System.out.println("=====查找"+empNo+"("+emptemp.getName()+")"+"成功！======\n");    
            }    
            else if(operType.equals("3"))    
            {    
                //显示所有员工信息    
                em.showAllInfo();    
                System.out.println("=====已列出！======\n");    
            }    
            else if(operType.equals("4"))    
            {    
                System.out.println("请输入编号：");    
                String empNo=br.readLine();    
                System.out.println("请输入工资：");    
                float sal=Float.parseFloat(br.readLine());    
                //修改    
                Emp emptemp=em.updateSal(empNo, sal);    
                System.out.println("=====修改"+empNo+"("+emptemp.getName()+")"+"工资成功！======\n");    
            }    
            else if(operType.equals("5"))    
            {    
                System.out.println("请输入编号：");    
                String empNo=br.readLine();    
                //删除    
                Emp emptemp=em.delEmp(empNo);    
                System.out.println("=====删除"+empNo+"("+emptemp.getName()+")"+"成功！======\n");    
            }    
            else if(operType.equals("6"))    
            {    
                //退出系统    
                System.exit(0);//0表示正常退出JVM,非0表示异常退出JVM    
            }    
        }    
            
    }    
   
}    
   
//雇员类    
class Emp    
{    
    //学号    
    private String empNo;    
    private String name;    
    private float sal;    
    public String getEmpNo() {    
        return empNo;    
    }    
    public void setEmpNo(String empNo) {    
        this.empNo = empNo;    
    }    
    public String getName() {    
        return name;    
    }    
    public void setName(String name) {    
        this.name = name;    
    }    
    public float getSal() {    
        return sal;    
    }    
    public void setSal(float sal) {    
        this.sal = sal;    
    }    
        
    //构造函数    
    public Emp(String empNo,String name,float sal)    
    {    
        this.empNo=empNo;    
        this.name=name;    
        this.sal=sal;    
    }    
}    
   
//雇员管理类    
class EmpManage    
{    
    private ArrayList al=null;    
    public EmpManage()    
    {    
        al=new ArrayList();    
    }    
    //加入员工    
    public Emp addEmp(Emp emp)    
    {    
        if(al.add(emp))//如果添加成功    
            return emp;    
        else   
            return null;    
    }    
    //显示指定员工的相关信息    
    public Emp showInfo(String empNo)    
    {    
        //遍历整个ArrayList    
        for(int i=0;i<al.size();i++)    
        {    
            //取出Emp对象    
            Emp emp=(Emp)al.get(i);    
            //比较编号    
            if(emp.getEmpNo().equals(empNo));    
            {    
                System.out.println("找到该员工，他的信息是：");    
                System.out.println("编号="+emp.getEmpNo());    
                System.out.println("名字="+emp.getName());    
                System.out.println("工资="+emp.getSal());    
                    
                return emp;    
            }    
        }    
        return null;    
    }    
    //显示所有员工的信息    
    public void showAllInfo()    
    {    
        //遍历整个ArrayList    
        for(int i=0;i<al.size();i++)    
        {    
            Emp emp=(Emp)al.get(i);    
            System.out.print("编号："+emp.getEmpNo()+" "   
                    +"名字："+emp.getName()+" "   
                    +"工资："+emp.getSal()+" "+"\n");    
        }    
    }    
    //修改工资    
    public Emp updateSal(String empNo,float newSal)    
    {    
        for(int i=0;i<al.size();i++)    
        {    
            Emp emp=(Emp)al.get(i);    
            if(emp.getEmpNo().equals(empNo))    
            {    
                //修改薪水    
                emp.setSal(newSal);    
                return emp;    
            }    
        }    
        return null;    
    }    
    //删除员工    
    public Emp delEmp(String empNo)    
    {    
            
        for(int i=0;i<al.size();i++)    
        {    
            Emp emp=(Emp)al.get(i);    
            if(emp.getEmpNo().equals(empNo))    
            {    
                al.remove(i);//按编号删除员工    
                al.remove(emp);//按对象删除员工    
                return emp;    
            }    
        }    
        return null;    
    }    
}  
Class7 / com.test1 / Demo7_3.java: 

/*   
 * 功能：各种集合的使用   
 */   
package com.test1;    
   
import java.util.HashMap;    
import java.util.Hashtable;    
import java.util.Iterator;    
import java.util.LinkedList;    
import java.util.Stack;    
import java.util.Vector;    
   
public class Demo7_3 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        //LinkedList的用法    
        LinkedList ll=new LinkedList();    
        Emp emp1=new Emp("sa01","宋江",1.2f);    
        Emp emp2=new Emp("sa02","卢俊义",1.8f);    
        Emp emp3=new Emp("sa03","吴用",1.5f);    
        //表示把emp1加在链表的最前面    
        ll.addFirst(emp1);//向链表的当前结点的前面添加一个emp1结点    
        ll.addFirst(emp2);//前加    
        ll.addLast(emp3);//后加    
        for(int i=0;i<ll.size();i++)    
        {    
            System.out.println(((Emp)ll.get(i)).getName());    
        }    
        //------------------------------------------------------    
        //Vector的用法    
        //Vector与ArrayList的区别    
        //1.Vector有同步机制，ArrayList没有同步机制     
        //2.ArrayList缺省情况下自动增长原来的一倍，Vector是原来的50%增长    
        Vector vv=new Vector();    
        Emp emp4=new Emp("1","林冲",1.6f);    
        vv.add(emp4);    
        for(int i=0;i<vv.size();i++)    
        {    
            Emp emp=(Emp)vv.get(i);    
            System.out.println(emp.getName());    
        }    
        //------------------------------------------------------    
        //栈的用法    
        Stack stack=new Stack();    
        Emp emp5=new Emp("8","李逵",1.9f);    
        Emp emp6=new Emp("9","武松",1.7f);    
        Emp emp7=new Emp("5","公孙胜",1.7f);    
        stack.add(emp5);    
        stack.add(emp6);    
        stack.add(emp7);    
        for(int i=0;i<stack.size();i++)    
        {    
            Emp emp=(Emp)stack.get(i);    
            System.out.println(emp.getName());    
        }    
        //------------------------------------------------------    
        //HashMap的用法    
        //创建一个HashMap对象    
        HashMap hm=new HashMap();    
        Emp emp8=new Emp("s001","秦平",2.2f);    
        Emp emp9=new Emp("s002","花荣",2.3f);    
        Emp emp10=new Emp("s002","燕青",2.4f);    
        //将emp放入到    
        hm.put("s001", emp8);    
        hm.put("s002", emp9);    
        hm.put("s002", emp10);//出现键值相同时，会将emp10替换前面的    
        System.out.println(emp8.getName());    
        System.out.println(emp9.getName());    
            
        //如果要查找编号是s002    
        if(hm.containsKey("s002"))    
        {    
            System.out.println("-----------\n有该员工");    
            //如何取出,键<-->值    
            Emp emp=(Emp)hm.get("s002");    
            System.out.println("名字："+emp.getName());    
        }    
        else   
        {    
            System.out.println("-----------\n没有该员工");    
        }    
            
        //遍历HashMap中所有的key和value    
        Iterator it=hm.keySet().iterator();//迭代器    
        //hasNext返回一个boolean    
        System.out.println("-------开始遍历HashMap！------");    
        while(it.hasNext())//hasNext判断是否还有下一个    
        {    
            //取出Key    
            String key=it.next().toString();    
            //通过Key取出value    
            Emp emp=(Emp)hm.get(key);    
            System.out.println("名字："+emp.getName());    
        }    
        //HashMap在多线程并发操作时，因为没有同步机制作，    
        //可能会发生读脏数据，所以引入了安全的Hashtable    
        //------------------------------------------------------    
        //Hashtable的用法    
        Hashtable ht=new Hashtable();    
        /*   
        ht.put(null, null);   
        System.out.println("Hashtable null值测试"+ht.get(null));   
        //Hashtable不可以存放空值   
        */   
        HashMap hm2=new HashMap();    
        hm2.put(null, null);//HashMap可以存放空值    
        System.out.println("HashMap null值测试:"+hm2.get(null));    
        //Hashtable不可以存放空值    
            
        /*   
         * 集合总结：   
         * 1.如果要求线程安全，使用Vector,Hashtable   
         * 2.如果要求线程安全，使用ArrayList,LinkedList,HashMap   
         * 3.如果要求键值对，则使用HashMap,Hashtable   
         * 4.如果数据量很大，又要线程安全考虑Vector   
         */   
    }    
} 
Class7 / com.test1 / Test1.java: 

/*   
 * 功能：位运算和移位运算   
 */   
   
package com.test1;    
   
public class Test1 {    
   
    /**   
     * @param args   
     */   
    public static void main(String[] args) {    
        System.out.println("~2="+(~2));//取反    
        System.out.println("2&3="+(2&3));//与    
        System.out.println("2|3="+(2|3));//或    
        System.out.println("~-5="+(~-5));//取反    
        System.out.println("-3^3="+(-3^3));//异或    
   
        //算术右移：低位溢出，符号位不变，并用符号位补溢出的高位    
        //算术左移：符号位不变，低位补0    
        //逻辑右移:低位溢出，高位补零    
        System.out.println("1>>2="+(1>>2));    
        System.out.println("-1>>2="+(-1>>2));    
        System.out.println("1<<2="+(1<<2));    
        System.out.println("-1<<2="+(-1<<2));    
        System.out.println("3>>>2="+(3>>>2));//逻辑右移    
    }    
}