Java第24天~25天/12.23~12.24

day24

Java设计模式

一、静态工厂模式（简单工厂模式）

静态工厂方法模式里面需要提供一个类:工厂类(用它制造一些需要的对象)
* 特点:
* 构造方法私有化,外界不能直接创建它的对象
* 提供静态功能,每一种静态都会产生所需要的对象…
* 缺点:不利于后期维护
* 如果添加新的对象,需要创建它的类还需要在静态工厂类提供一些功能!

package org.westos_01_简单工厂模式;
/**
 * 静态工厂方法模式里面需要提供一个类:工厂类(用它制造一些需要的对象)
 *      特点:
 *          构造方法私有化,外界不能直接创建它的对象
 *          提供静态功能,每一种静态都会产生所需要的对象...
 *      缺点:不利于后期维护
 *          如果添加新的对象,需要创建它的类还需要在静态工厂类提供一些功能!
 * @author 小鑫
 *
 */
public class AnimalDemo {

    public static void main(String[] args) {

        //提供静态工厂
        Animal a = AnimalFactory.createAnimal("dog");
        a.eat();
        a = AnimalFactory.createAnimal("cat");
        a.eat();
        a = AnimalFactory.createAnimal("pig");
        if(a!=null){
            a.eat();
        }else{
            System.out.println("工厂类没有提供该动物");
        }
        /*
         * 狗吃肉 
         * 猫吃鱼 
         * 工厂类没有提供该动物
         */

    }
}

package org.westos_01_简单工厂模式;

public abstract class Animal {

    public abstract void eat();
}

class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃肉");

    }

}

class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");

    }

}

package org.westos_01_简单工厂模式;
/**
 * 动物工厂类
 * @author 小鑫
 *
 */
public class AnimalFactory {

    //私有功能
    private AnimalFactory(){

    }

    public static Animal createAnimal(String type){
        if("dog".equals(type)){
            return new Dog();
        }else if("cat".equals(type)){
            return new Cat();
        }else{
            return null;
        }

    }
}

二、工厂方法模式

工厂方法模式:
* 特点:
* 需要提供一个抽象类,以及每个动物的具体类和接口(工厂接口)
* 该接口中的抽象方法的返回值是该抽象类
* 针对每个具体动物都提供一些对应的工厂类—>实现该接口—>返回值就是需要具体的动物对象

package org.westos_02_工厂方法模式;
/**
 * 工厂方法模式:
 *   特点:
 *      需要提供一个抽象类,以及每个动物的具体类和接口(工厂接口)
 *      该接口中的抽象方法的返回值是该抽象类
 *      针对每个具体动物都提供一些对应的工厂类--->实现该接口--->返回值就是需要具体的动物对象
 * 
 *     弊端:代码量大了.
 * @author 小鑫
 *
 */
public class AnimalDemo {

    public static void main(String[] args) {
        //需求： 养一只狗
        DogFactory df = new DogFactory();
        Animal a = df.cereatAnimal();
        a.eat();

        //养一只猫
        CatFactory cf = new CatFactory();
        a = cf.cereatAnimal();
        a.eat();
        //狗吃肉
        //猫吃鱼
    }
}

package org.westos_02_工厂方法模式;

public abstract class Animal {

    public abstract void eat();
}

class Cat extends Animal{

    @Override
    public void eat() {
        System.out.println("猫吃鱼");  
    }   
}

class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

}

package org.westos_02_工厂方法模式;
//工厂接口
public interface Factory {

    //提供常见动物功能
    public abstract Animal cereatAnimal();
}

//猫工厂类提供对象
class CatFactory implements Factory{

    @Override
    public Animal cereatAnimal() {
        return new Cat();
    }   
}

//狗工厂提供对象
class DogFactory implements Factory{

    @Override
    public Animal cereatAnimal() {
        return new Dog();
    }
}

三、单例模式

单例模式:在内存中始终只有一个对象

• 饿汉式
• 特点:当前某一个一加载,就会创建一个对象
• 需要将该类的无参构造私有化
• 在成员变量创建该类的实例
• 需要提供公共的访问方法
• 懒汉式
• 特点:并不是加载某个类就直接创建对象,而是需要的时候在创建对象
• 1)懒加载(延迟加载)
• 2)线程的安全问题
• 检验标准:
• a:是否是多线程环境
• b:是否有共享数据1
• c:是否有多条语句对共享数据进行操作!
• 使用同步代码块进行解决

1、饿汉式

package org.westos_03_单例模式;
/**                 
 *      饿汉式
 *          特点:当前某一个一加载,就会创建一个对象
 *          需要将该类的无参构造私有化
 *          在成员变量创建该类的实例
 *          需要提供公共的访问方法
 * @author 小鑫
 *
 */
public class StudentDemo {

    public static void main(String[] args) {

        //利用静态公共访问方法创建对象
        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1==s2);//true
        System.out.println(s1);//org.westos_03_单例模式.Student@3654919e
        System.out.println(s2);//org.westos_03_单例模式.Student@3654919e
    }
}

package org.westos_03_单例模式;

public class Student {

    //无参构造私有化，不让外界创建对象
    private Student(){

    }
    //在成员变量位置创建该类实例
    //静态只能访问静态，static修饰
    private static Student s=new Student();
    //提供公共访问方法，返回该类实例对象
    public static Student getStudent(){
        return s;

    }
}

2、懒汉式

package org.westos_03_单例模式;
/**
*    懒汉式
 * 特点:并不是加载某个类就直接创建对象,而是需要的时候在创建对象
 *          1)懒加载(延迟加载)
 *          2)线程的安全问题
 *              检验标准:
 *                  a:是否是多线程环境
 *                  b:是否有共享数据1
 *                  c:是否有多条语句对共享数据进行操作!
 *         使用同步代码块进行解决
 * @author 小鑫
 */
public class TeacherDemo {

    public static void main(String[] args) {

        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();

        System.out.println(t1==t2);//true
        System.out.println(t1);//org.westos_03_单例模式.Teacher@6084fa6a
        System.out.println(t2);//org.westos_03_单例模式.Teacher@6084fa6a
    }
}

package org.westos_03_单例模式;

public class Teacher {

    // 构造方法私有化
    private Teacher() {

    }

    // 成员位置声明变量
    private static Teacher t = null;//共享数据

    //提供公共放访问方法
    public synchronized static Teacher getTeacher(){
        //判断 当当前该对象没有更多引用的时候,才创建对象
        if(t==null){
             t = new Teacher();
        }
        return t;
    }
}

四、装饰者模式

package org.westos_04_装饰者模式;

public class PhoneDemo {

    public static void main(String[] args) {

        // 打电话
        Phone p = new IPhone();
        p.call();// 手机可以打电话了...
        System.out.println("-----------");

        // 打电话前听彩铃
        PhoneDecorate pd = new RingPhoneDecorate(p);
        pd.call();
        // 手机可以听彩铃...
        // 手机可以打电话了...
        System.out.println("------------");

        // 打完电话，听音乐
        pd = new MusicPhoneDecorate(p);
        pd.call();
        // 手机可以打电话了...
        // 手机可以听音乐了...
        System.out.println("-----------");

        // 改进：先听彩铃，然后打电话，最后听音乐
        pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
        pd.call();
        /*手机可以听彩铃...
        手机可以打电话了...
        手机可以听音乐了...*/
    }
}

package org.westos_04_装饰者模式;
//打电话接口
public interface Phone {

    public abstract void call();
}

//具体手机类
class IPhone implements Phone{

    @Override
    public void call() {
        System.out.println("手机可以打电话了...");
    }

}

package org.westos_04_装饰者模式;

public class MusicPhoneDecorate extends PhoneDecorate {

    public MusicPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        super.call();
        System.out.println("手机可以听音乐了...");

    }
}

package org.westos_04_装饰者模式;

public class PhoneDecorate implements Phone{

    private Phone p;

    public PhoneDecorate(Phone p){
        this.p=p;
    }

    @Override
    public void call() {
        this.p.call();

    }

}

package org.westos_04_装饰者模式;

public class RingPhoneDecorate extends PhoneDecorate {

    public RingPhoneDecorate(Phone p) {
        super(p);
    }

    @Override
    public void call() {
        System.out.println("手机可以听彩铃...");
        super.call();
    }
}

五、枚举

package org.westos_05_枚举;
//测试类
public class DirectionDemo {

    public static void main(String[] args) {

        Direction1 front = Direction1.FRONT;
        System.out.println(front);
        //org.westos_05_枚举.Direction1@6a2437ef
        System.out.println("--------------");

        Direction2 behind = Direction2.BEHIND;
        System.out.println(behind);
        //org.westos_05_枚举.Direction2@3cf5b814
        String name = behind.getName();
        System.out.println(name);//后
        System.out.println("--------------");

        Direction3 left = Direction3.LEFT;
        System.out.println(left.getName());//左
        left.show();//左
    }
}

package org.westos_05_枚举;

public class Direction1 {

    // 创建实例对象
    public static final Direction1 FRONT = new Direction1();
    public static final Direction1 BEHIND = new Direction1();
    public static final Direction1 LEFT = new Direction1();
    public static final Direction1 RIGHT = new Direction1();

    //提供公共构造方法
    public Direction1(){

    }
}

package org.westos_05_枚举;

public class Direction2 {

    // 创建几个实例对象
    public static final Direction2 FRONT = new Direction2("前");
    public static final Direction2 BEHIND = new Direction2("后");
    public static final Direction2 LEFT = new Direction2("左");
    public static final Direction2 RIGHT = new Direction2("右");

    //私有化无参构造
    private Direction2(){

    }
    private String name;
    public Direction2(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
}

package org.westos_05_枚举;

public abstract class Direction3 {

    //提供子实现类
    public static final Direction3 FRONT=new Direction3("前"){

        @Override
        public void show() {
            System.out.println("前");    
        }   
    };
    public static final Direction3 BEHIND=new Direction3("后"){

        @Override
        public void show() {
            System.out.println("后");    
        }   
    };
    public static final Direction3 LEFT=new Direction3("左"){

        @Override
        public void show() {
            System.out.println("左");    
        }   
    };
    public static final Direction3 RIGHT=new Direction3("右"){

        @Override
        public void show() {
            System.out.println("右");    
        }   
    };


private Direction3(){

    }
    private String name ;

    public Direction3(String name) {
        this.name = name ;
    }

    public String getName(){
        return name ;
    }

    //抽象方法
    public abstract void show();
}

六、枚举

package org.westos_06_枚举;

public class DirectionDemo {

    public static void main(String[] args) {

        Direction1 front = Direction1.FRONT;
        System.out.println(front);//FRONT    枚举里面直接输出当前实例名称
        System.out.println("-------------");

        Direction2 behind = Direction2.BEHIND;
        System.out.println(behind);
        String name = behind.getName();//BEHIND
        System.out.println(name);//后
        System.out.println("-------------");

        Direction3 left = Direction3.LEFT;
        System.out.println(left);//LEFT
        System.out.println(left.getName());//左
        left.show();//左
    }
}

package org.westos_06_枚举;

public enum Direction1 {

    // 创建几个实例
    FRONT, BEHIND, LEFT, RIGHT;
}

package org.westos_06_枚举;

public enum Direction2 {

    FRONT("前"),BEHIND("后"),LEFT("左"),RIGHT("右");

    private String name;
    private Direction2(String name){
        this.name=name;
    }

    public String getName(){
        return name;
    }
}

package org.westos_06_枚举;

public enum Direction3 {

    FRONT("前"){

        @Override
        public void show() {
            System.out.println("前");            
        }       
    }
    ,
    BEHIND("后"){

        @Override
        public void show() {
            System.out.println("后");            
        }       
    }
    ,
    LEFT("左"){

        @Override
        public void show() {
            System.out.println("左");            
        }       
    }
    ,
    RIGHT("右"){

        @Override
        public void show() {
            System.out.println("右");            
        }       
    }
    ;

private String name ;

    private Direction3(String name){
        this.name = name ;
    }

    public String getName(){
        return name ;
    }

    public abstract void show();
}

JavaSE测试题

1.在JAVA中，下列哪些说法是正确的（AC）
A．java源文件的扩展名为.java
B．写好的java源程序可以直接运行
C．编写的源程序必须先编译后才能运行
D．程序员可以读懂扩展名为.class的文件

2.下列标识符哪个是合法的（BD）
A．class
B．$abc
C．1234
D．_name

3.下面哪些赋值语句是正确的?(A)
A. long test = 012;
B. int other = (int) true;
C. double d = 0x12345678;
D. byte b = 128;

4.在Java中，下列语句不能通过编译的有(BD)
A. String s= “join”+ 3;
B. int a= “join”+3;
C. int a= ‘a’+5;
D. float f=5+5.5;

5.下列代码运行的结果是( C)

public static void main(String[] args) {
    int x = 4;
    int y = 5;
    if(x++>4 & ++y>5) {   //X=5,Y=6
        x++;
    }
    System.out.println("x=" + x + ",y=" + y);

}

A. x=4,y=5
B. x=4,y=6
C. x=5,y=6
D. x=6,y=6

6.尝试运行下面的代码会发生什么？(B)

public class Test {
    public static void main(String[] args) {
        boolean m = true;
        if (m = false) {
            System.out.println("true");
        } else {
            System.out.println("false");
        }
    }
}

A. 输出字符串”true”
B. 输出字符串”false”
C. 编译时错误
D. 运行时错误

7.编译并运行以下代码将发生什么？ （ E）

public static void main(String args[]){
        char digit = 'a';
        for (int i = 0; i < 10; i++){
            switch (digit)
            {
                    case 'x' :
                    {
                        int j = 0;
                        System.out.println(j);      
                    }
                    default :
                    {
                        int j = 100;
                        System.out.println(j);      
                    }
            }
    }
    int i = j;
    System.out.println(i);  
}

A. 输出11次100
B. 输出10次100，然后抛出运行期异常
C. 编译错误，因为变量i不能在main() 方法中被声明2次
D. 编译错误，因为变量j不能在main() 方法中被声明2次
E. 以上都不对

8.（B）

class Demo   
{
    public static int fun(int c)
{
        return  c+=2;
    }
    public static void main(String[] args) 
{
        int temp = fun(2);
        System.out.println(temp);
    }
}

A. 2
B. 4
C. 6
D. 8

9.下面哪些函数是public void aMethod(){…}的重载函数?(BD)
A. void aMethod( ){…}
B. public int aMethod(int a, float b){…}
C. public void aMethod (){…}
D. public float aMethod (int m){…}
//返回值类型不能作为是否是重载方法的判断依据

10.在java中，关于数组描述正确的是（BD）
A．数组中的索引下标从1开始
B．存储在数组当中的数据都属于同一数据类型
C．通过数组名.length()能获得数组的长度
D．数组的最大索引下标是数组的长度减1

11.下面程序的输出结果是什么(D )
int[] arr = new int[10];
System.out.println(arr[0]);
A．编译不通过
B．运行时出错
C．输出null
D．输出0

12.下面哪个语句正确地声明一个整型的二维数组( C)
A. int a[][] = new int[][];
B. int b[10][10] = new int[][];
C. int c[][] = new int[10][10];

13.以下代码输出是（ D ）

class Demo {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while (i <= 10) {
            i++;
            if (i % 2 != 0)
                continue;
            sum += i;

        }
        System.out.println(sum);
    }
}

A. 55
B. 45
C. 35
D. 30

14.和下面代码能完成相同的选项是（B）

class Demo {
    public static void main(String[] args) {
        int i = 1;
        int sum = 0;
        while (i <= 100) {
            if (i % 2 == 0) {
                sum = sum + i;
            }
            i++;
        }
        System.out.println(sum);
    }
}　　

A. for (int x =1; x<=100;x++){ sum=sum+x;}
B. for (int x =0; x<=100;x+=2){ sum=sum+x;}
C. for (int x =1; x<=100;x+=2){ sum=sum+x;}
D.上述全对

15.下列有关类、对象和实例的叙述，正确的是哪一项？(D)
A．类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别
B．对象是类的抽象，类是对象的具体化，实例是对象的另一个名称
C．类是对象的抽象，对象是类的具体化，实例是类的另一个名称
D．类是对象的抽象，对象是类的具体化，实例是对象的另一个名称

16.下面关于java中包的说法正确的是(ACD)
A. 在java中可以使用import语句导入包
B. 在java中可以使用package语句导入包
C. 位于同一个包中的类，不需要导包就可以直接访问
D. 不同的包中可以出现类名相同的类

17.下列有关抽象类的叙述正确的是哪项？(C)
A．抽象类中一定含有抽象方法
B．抽象类既能被实例化也能被继承
C．抽象类的声明必须包含abstract关键字
D．抽象类中不能有构造方法

18.下列有关接口的叙述错误的是哪项？(CD)
A．接口中只能包含抽象方法和常量
B．一个类可以实现多个接口
C．类实现接口时必须实现其中的方法
D．接口不能被继承

19.下列关于类的继承的描述，正确的有（ BD ）
A. 一个类可以同时继承多个父类
B. 一个类可以具有多个子类
C. 子类会自动拥有父类所有的方法
D. 一个类继承另一个类需要使用 extends 关键字

20.下列选项中关于java中this关键字的说法错误的有( C )
A. this关键字是一个对象的引用
B. this可用于构造函数中，调用类本身重载的构造函数，但是必须写在首行
C. this可用于静态方法中

21.下列关于构造函数的说法正确的是( AB )
A. 方法名必须与类名相同
B. 使用new关键字创建对象时，java虚拟机会自动调用构造函数
C. 我们在定义一个类时，必须要声明至少一个构造函数
D. 构造函数中不能使用return语句(这个是错的，可以rutrun;)

22.编译并运行以下代码将发生什么？( D )

class MyClass {
    int x;
    MyClass(int i) {
        x = i;
    }
    public static void main(String args[]) {
        MyClass m1 = new MyClass(100);
        MyClass m2 = new MyClass(100);
        if (m1.equals(m2)) {
            System.out.println("Both are equal");
        } else {
            System.out.println("Both are not equal");
        }   
    }
}

A. 代码编译时报出错误提示信息“equals() 方法未定义”
B. 编译通过，抛出运行期异常.
C. 输出Both are equal.
D. 输出Both are not equal

23.运行以下的main()方法，结果是？（ A ）

1   public static void main(String[] args)
2   {
3       String myString;
4       int x = 100;
5     
6       if (x < 100) myString = "x is less than 100";
7       if (x > 100) myString = "x is greater than 100";
8       System.out.println(myString.length());
9   }

A． 编译时报出错误提示信息“变量myString没有被初始化”
B． 编译通过
C． 编译未能通过。但如果变量myString在第8行前的代码中被初始化，代码可以编译通过，运行时可以输出字符串myString的长度
D． 以上都不对

24.关于继承, 以下说法正确的是: (A)
A．Java中只支持单继承, 一个类只能继承一个类, 但是可以有多个子类
B．一个类如果没有自己写无参构造方法, 那么子类将无法继承
C．子类可以当父类用, 父类不可以当子类用
D. 子类重写父类方法时访问权限不能更低

25.在Java中，如果要在字符串类型对象s=”java”中，得到字符 ‘v’ 出现的位置，可使用下面的那个方法?（ C ）
A. s.matches(‘v’);
B. s.charAt(‘v’);
C. s.indexOf(‘v’);
D. s.substring(‘v’);

26.下列关于ArrayList和LinkedList集合的说法正确是有( ABC )
A. ArrayList集合底层是数组实现，该集合线程不安全
B. LinkedList集合底层是链表结构，适合做元素的增删操作
C. 这三个集合都是List接口的实现类

27.下面程序的输出结果是什么( D )
Set set= new HashSet();
set.add(“aaa”);
set.add(“bbb”);
set.add(“aaa”);
System.out.println(set.size());
A. 编译不通过
B. 运行时出错
C. 输出3
D. 输出2

28.下列哪些方法是ArrayList和LinkedList集合中都定义的( ACD )
A. add(Object o)
B. removeFirst()
C. remove(Object o)
D. add(int index,Object o)

29.下列哪些集合属于Collection体系的子类( BD )
A. TreeMap
B. ArrayList
C. Hashtable
D. HashSet

30.下列关键字能和try语句一起使用的是( CD )
A. final
B. finalize
C. finally
D. catch

31.下面程序的运行结果是( C )
FileOutputStream fos = new FileOutputStream(“c:\demo.txt”);
fos.write(“abc”);
fos.close();
A．在C盘创建文件demo.txt,但文件是空的
B．在C盘创建文件demo.txt,并写入数据abc
C．将C盘已有的文件demo.txt中追加写入abc
D．编译失败

32.下列关于Java中文件输入输出的说法正确的是（ AC ）
A. 在Java中，文件的输入输出功能是通过流来实现的
B. 如果要把数据写入到一个文件中，需要创建一个输入流对象
C. 字符流在某些方面比如汉字的处理，比字节流更方便
D. 可以通过Reader r = new Reader(“c:\pet.txt”)创建一个输入流对象

33.请看如下代码：

BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\b.txt"));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
    bw.newLine();
bw.flush();
}
bw.close();
br.close();

它表达的意思是?（ A ）
A. 把c盘目录下的a.txt文件内容复制到d盘目录下的b.txt
B. 把d盘目录下的b.txt文件内容复制到c盘目录下的a.txt
C. 读取c盘目录下a.txt文件，输出在控制台
D. 把控制台的内容写入到d盘目录下的b.txt文件中

34.下列哪个关键字可以用于实现同步？( C )
A. native
B. static
C. synchronized
D. abstract

35.下列哪些方法可以让线程中断? ( AD )
A. sleep
B. start
C. notify
D. wait

36.启动线程调用哪个方法? ( B)
A. run()
B. start()
C. play()
D. go()

37.下面哪项不是TCP的特点? ( B )
A．面向连接
B．数据不可靠
C．传输速度慢
D．对数据大小无限制

38.TCP协议的服务器的Socket对象是下面哪一个类? ( C )
A．Socket
B．InputStream
C．ServerSocket
D．OutputStream

39.正则表达式中可以表示所有的单词字符信息的是下面哪个规则：( C )
A． \W
B． \w
C． [a-zA-Z]
D．[a-zA-Z_0-9]

40.获取Class类型的对象的三种方式是：( ABD )
B. class静态属性
A. Object类的getClass()
D. Class类的forName()静态方法
C. 自己创建Class对象

编程：（4*5）
1. 把c:\a.jpg复制到d:\b.jpg(任意一种方式实现即可)

package org.westos_homework;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 把c:\\a.jpg复制到d:\\b.jpg(任意一种方式实现即可)
 * 
 * 分析： 使用字节缓冲流，一次读取一个字节数组
 * 
 * @author 小鑫
 * 
 */
public class HomeWork1 {

    public static void main(String[] args) throws IOException {

        // 封装数据源
        FileInputStream fis = new FileInputStream("C:\\a.jpg");
        // 封装目的地
        FileOutputStream fos = new FileOutputStream("D:\\b.jpg");
        //一次读取一个字节数组
        byte[] bys=new byte[1024];
        int len=0;
        while((len=fis.read(bys))!=-1){
            fos.write(bys, 0, len);
            fos.flush();
        }
        fis.close();
        fos.close();
    }
}

1. HashMap的键是Integer,值是String，存储三对元素，并遍历。(根据键找值的方式遍历)

package org.westos_homework;

import java.util.HashMap;
import java.util.Set;

/**
 * HashMap的键是Integer,值是String，存储三对元素，并遍历。(根据键找值的方式遍历)
 * 
 * @author 小鑫
 * 
 */
public class HomeWork2 {

    public static void main(String[] args) {

        //创建HashMap集合
        HashMap<Integer, String> hm = new HashMap<Integer, String>();
        //添加元素
        hm.put(3, "韦德");
        hm.put(1, "麦迪");
        hm.put(24, "科比");
        //获取键集合
        Set<Integer> keySet = hm.keySet();
        for (Integer key : keySet) {
            String value = hm.get(key);
            System.out.println(key+"---"+value);
            /*1---麦迪
              3---韦德
              24---科比*/

        }
    }
}

3.键盘录入5个数字，使用冒泡排序进行排序

package org.westos_homework;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 键盘录入5个数字，使用冒泡排序进行排序
 * 
 * @author 小鑫
 * 
 */
public class HomeWork3 {

    public static void main(String[] args) {

        // 键盘录入
        int count = 0;
        int[] arr = new int[5];
        // 循环输入5个整数
        while (count < 5) {
            Scanner sc = new Scanner(System.in);
            try {
                // 输入整数放到数组中
                System.out.println("请输入第" + (count+1) + "个整数");
                arr[count] = sc.nextInt();
                count++;
            } catch (Exception e) {
                // 不是整数则走异常
                System.out.println("请输入整数");
            }
        }
        System.out.println("排序前的数组是" + Arrays.toString(arr));

        // 冒泡排序，两两比较，大的往后移
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                // 判断
                if (arr[y] > arr[y + 1]) {
                    int temp = arr[y];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

4.请在main方法里面实现统计一个字符串的英文大写字符，英文小写字符及数字字符分别有多少个的程序代码，并输出统计结果。

package org.westos_homework;

import java.util.Scanner;

/**
 * 请在main方法里面实现统计一个字符串的英文大写字符，英文小写字符及数字字符
 * 分别有多少个的程序代码，并输出统计结果。
 * @author 小鑫
 *
 */
public class HomeWork4 {

    public static void main(String[] args) {

        //键盘录入
        Scanner sc = new Scanner(System.in);
        String line = sc.nextLine();
        char[] ch = line.toCharArray();
        //定义统计变量
        int upperCount=0;
        int lowerCount=0;
        int numberCount=0;
        for(int i=0;i<ch.length ;i++){
            if(Character.isDigit(ch[i])){
                numberCount++;
            }else if(Character.isLowerCase(ch[i])){
                lowerCount++;
            }else if(Character.isUpperCase(ch[i])){
                upperCount++;
            }
        }
        System.out.println("数字个数有"+numberCount+"个");
        System.out.println("小写字符个数有"+lowerCount+"个");
        System.out.println("大写字符有"+upperCount+"个");
        /*dfsf55MKDD4dsD
             数字个数有3个
             小写字符个数有6个
             大写字符有5个*/

    }
}