知不知

/*  
 * 功能：数组的必要性  
 */  
  
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));   
    }   
}

/*  
 * 功能：对象数组的使用  
 */  
  
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;   
    }   
}  

/*  
 * 功能：二维数组  
 */  
  
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");   
        }   
    }   
}

/*  
 * 功能：演示各种排序法  
 */  
  
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);            
    }   
}  

/*  
 * 功能：二分查找  
 */  
  
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("没有找到！");   
        }   
    }   
}

/*  
 * 功能：演示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;   
    }   
} 

/*  
 * 功能：做一个公司职员薪水管理系统，要求完成如下功能 ：  
 * 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;   
    }   
} 

/*  
 * 功能：各种集合的使用  
 */  
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  
         */  
    }   
}

/*  
 * 功能：位运算和移位运算  
 */  
  
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));//逻辑右移   
    }   
}