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

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量109 收藏
点赞数
分类专栏： Java 文章标签： java 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sgj_4732514/article/details/84270876
版权
[color=blue][size=x-large]文件结构 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643223372.png[/img] 


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");    
        }    
    }    
}



[color=blue][size=x-large]排序与查找

排序介绍 [/size][/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643247077.png[/img]

[color=darkblue]冒泡排序[/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643258124.png[/img]
[color=blue]选择排序[/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643256139.png[/img]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643251646.png[/img]
[color=blue]快速排序 [/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643266007.png[/img]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643276497.png[/img] 

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("没有找到！");    
        }    
    }    
}


[color=blue]集合类及移位运算 [/color]
[img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/20110607164327368.png[/img][img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/201106071643281415.png[/img][img]http://images.cnblogs.com/cnblogs_com/luowei010101/201106/20110607164329170.png[/img] 

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));//逻辑右移    
    }    
}
sgj_4732514
关注
专栏目录
java 右移两位_java中的位操作、移位操作
weixin_39947351的博客
02-13 2211
在日常开发中，其实位操作、移位操作的使用并不多，主要是其可读性较差，但是在计算密集型操作如一致性哈希计算、hashmap扩容、取数据的交集、差集、并集、权限开关位，位操作、移位操作被广泛使用。因此本文章来介绍Java中的位操作、移位操作，当然LZ特别说明我们的使用场景。一、 相关基础概念在开始java位运算的知识之前，我们先来了解几个基础的概念，机器数，真值，原码，反码，补码。1.机器数我们知道无...
毕向东Java笔记（全部）
weixin_41700993的博客
05-09 2208
文章目录目录DOS命令进制转换数据类型定义变量的格式类型转换转义字符赋值运算符逻辑运算符位运算符 目录 DOS命令 在DOS里新建文件 copy con Demo.java class Demo{ public static void main(String[] args){ System.out.println("Hello Java"); } } Ctrl+Z 保存 type Demo...
JAVA--希尔排序采用移位法实现
yuchen_lucky的博客
04-07 337
package cm.zc; import java.util.Arrays; /** * 希尔排序采用移位法实现 * @author D * */ public class ShellSort { public static void main(String[] args) { int [] arr= {8,9,1,7,2,3,5,4,6,0}; shellSort(arr...
集合的移位操作
wangyanming123的博客
07-18 625
集合的循环移位操作
Java中的左移、右移详细分析
热门推荐
The best are water的博客
06-19 2万+
<<表示左移，不分正负数，低位补0； 注：以下数据类型默认为byte-8位 左移时不管正负，低位补0 正数：**r = 20 << 2** 　　20的二进制补码：0001 0100 　　向左移动两位后：0101 0000 　　　　 　　结果：r = 80 负数：**r = -20 << 2** 　　-20 的二进制原码 ：1001 0100 ...
Java学习笔记-集合框架之类篇
编程使我快乐
09-17 141
图1：集合框架的子类 现在，让我们将话题从接口的转移到实现接口的类上。前面曾经讨论过，集合接口有大量的方法，这些方法可以通过更基本的方法加以实现。 1.AbstractCollection类 该类提供了Collection接口的骨架实现，以尽量减少实现此接口所需的工作量。 为了实现一个不可修改的集合，程序员只需要扩展这个类并提供iterator和size方法的实现。 （ iterator方法返回...
Java集合整理笔记
是袁同学呀
07-02 703
个人闲暇时整理的Java集合相关笔记，第一部分是简单理解一下基本概念，第二部分是总结十道常考面试题。个人能力有限，文字比较主观，如有描述不当敬请指正~
java笔记搞死人__数组5-2
BettenMan_K的博客
03-26 287
【1、掌握冒泡排序算法】（重点） 掌握冒泡排序的原理 比较：相邻元素进行比较，两两比较 ，小的靠前，大的靠后（升序） 冒泡排序的口诀：n表示数字的个数 外层循环 n-1 表示比较的轮廓 内层循环 n-1-i 表示每轮比较的次数 例： /** * 冒泡排序： * 相邻元素作比较 两两比较小靠前 * 代码口诀：外层循环n-1 内层循环n-1-i (n代表元素个...
java笔记——Java集合框架
theone_ID的博客
10-20 754
上课学习笔记
Java笔记
weixin_43091461的博客
05-21 947
Java复习手册 基础语法 概述 Java的特性 简单性 为了便于系统理解，Java语法在设计时尽可能地接近C++，但Java语法是C++语法的一个“纯净”版本，剔除了C++中许多很少使用、难以理解、容易混淆的特性。不过设计者没有试图清除C++中所有的特性，例如switch语句的语法在Java中就没有改变。 “简单”的另一方面是小，Java的目标之一是支持开发能够在小型机器上独立运行的软件。 面向对象 面向对象设计是一种程序设计技术，它将重点放在数据（即对象）和对象的接口上。用木匠打一个比方，“面向
Java核心技术· 卷一（11版）笔记（第1-3章）
weixin_43647460的博客
10-22 597
Java是一种跨平台的编程语言，广泛应用于企业级应用、嵌入式系统、移动应用等领域。Java程序可以在不同的操作系统和硬件平台上运行，具有高效性、安全性、稳定性等特点。Java程序的编写需要使用Java开发工具，如Eclipse、NetBeans、IntelliJ IDEA等。编写完成后，Java程序需要通过编译器将其转换为字节码，然后再通过Java虚拟机（JVM）解释执行。Java程序的基本组成部分包括类、对象、方法、变量、运算符等，Java程序也支持面向对象编程的特性，如封装、继承和多态。
Java集合框架(复习笔记+重难点理解)
super_song的博客
01-25 2166
一、集合概述 1.概念： 存储对象的容器，定义了对多个对象进项操作的的常用方法。可实现数组的功能 2.和数组的区别 1.数组长度固定，集合长度不固定 2.数组可以存储基本类型和引用类型，集合只能存储引用类型 基本类型数据装箱，转为引用类型也可以存集合里，集合类位于java.util包中 二、Collection体系集合 有序指添加顺序和遍历顺序一致，无序指添加顺序和遍历顺序不一定一致 1.Collection父接口 1.特点 代表一组任意类型的对象，部分有序，部分无序 2.方法 boolean add(O
Java包装类,异常,集合,多线程,反射，IO，String类，lambda表达式，File类
zhufei09096651的博客
05-27 539
API基础第一天： 笔记： String：字符串类型 java.lang.String使用的final修饰，不能被继承 字符串底层封装了字符数组以及针对字符数组的操作算法 Java字符串在内存中采用Unicode编码方式，任何一个字符对应两个字节的编码 字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值 常量池： java对字符串有一个优化措施：字符串常量池(堆中) java推荐我们使用字面量/直接量的方式来创建字符串，并且会缓存所有以字面量形式创建的字符串对象到常量池中，当使用相
java list 上移动一个位置。下移动一个位置
Lostboy船长
06-10 7774
public static void listAddOne(List list) {     int a= list.get(0);     for (int i = 0; i           if (i==list.size()-1){             list.set(i,a);         }else {               list.set(i,li
spring事务详细讲解-深入浅出
小电玩
09-08 542
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1527
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 590
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
Java集合类笔记：List与ArrayList详解及自定义Map实现
Java笔记——集合类 Java编程中，集合类是数据存储和操作的核心组成部分，它提供了丰富的数据结构以支持各种应用场景。本笔记主要聚焦于List和Map这两个核心接口，以及它们的实现类——ArrayList和HashMap。 首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值