java学习code

发表于 | 更新于 | 分类于 | 阅读次数：

####代码1：大象放冰箱

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package day1;
import java.util.Scanner;
class elephone{
    String name;
    public String put(){
        return name;
    }
}
class icebox{
    public void open()
    {
        System.out.println("打开了冰箱");
    }
    public void save(String name)
    {
        System.out.println("放入"+name);
    }
    public void close()
    {
        System.out.println("关闭了冰箱");
    }
}


public class day1 {
    public static void main(String [] args)
    {
        icebox ice = new icebox(); //实例化对象
        ice.open();  //调用打开方法
        elephone ele = new elephone();
        Scanner sc = new Scanner(System.in);
        ele.name = sc.next();
        String name = ele.put();
        ice.save(name);
        ice.close();//调用关闭方法
    }

}

代码2：小汽车

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package day1;
class Car{
    String color;
    int num;
    public void run()
    {
        System.out.println("汽车运行,颜色为"+color+",车轮数"+num);
    }
}
public class day1 {
    public static void main(String [] args)
    {
        /*代码2:小汽车*/
        Car car = new Car();
        car.color = "绿色";
        car.num = 4;
        car.run();
    }

}

####代码3：局部变量和成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class day1 {
    int day;
    public static void main(String [] args)
    {
        /*局部变量和成员变量*/
        int day = 4;
        day1 day_ = new day1();
        day_.get_num();
        System.out.println(day);
    }
    public void get_num()
    {
        day = 5;
    }

}


package day2;

class Person{
    private String name = "是打算大";
    private int age = 20;

    public void set_age(int age)
    {
        this.age = age;
    }
    public int get_age()
    {
        return this.age;
    }
    public void set_name(String name)
    {
        this.name = name;
    }
    public String get_name()
    {
        return this.name;
    }
    public void get_info()
    {
        name = this.get_name();
        age = this.get_age();
        System.out.println(name + age);
    }
}

public class get_set {
    public  static  void  main(String [] args)
    {
        Person person = new Person();
        person.get_info();
        person.set_age(25);
        person.set_name("小米");
        System.out.println(person.get_age());
        person.get_info();
    }
}

代码4:判断是否是同一个人

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
数值相等判断用 = ,字符串相等用equals A.equals(B)

package day2;
class Person_ {
    private String name;
    private int age;
    public  Person_(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String get_name()
    {
        return this.name;
    }
    public int get_age()
    {
        return this.age;
    }
}
public class new_Person {
    public static void main(String [] agrs)
    {
        Person_ person1 = new Person_("张三",20);
        Person_ person2 = new Person_("张三",20);
        if ((person1.get_name().equals(person2.get_name()))&&((person1.get_age() == (person2.get_age())))) {System.out.println("人一样");};
    }
}

代码5:随机点名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package day2;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

//public class
class Student{
    private String name; //姓名
    private int age; //年龄
    //设置姓名\年龄,即可以使用构造.也可以set和get
    public Student(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    //取名字
    public String getname()
    {
        return this.name;
    }
    //取年龄
    public int getage()
    {
        return this.age;
    }
}

public class demo3 {
    public static void main(String [] agrs){
        //随机点名分三步
        //第一步,录入学生信息
        ArrayList<Student> list = new ArrayList<Student>();
        setmessage(list);
        System.out.println(list.size());
        //第二步:打印所有学生信息
        Pintlist(list);
        //第三步:随机取数打印
        randomstudent(list);
    }
    public static void setmessage(ArrayList<Student> list)
    {
        for(int i=0;i<=3;i++)
        {
            Scanner sc = new Scanner(System.in);
            System.out.println("请录入中文名");
            String name = sc.next();
            System.out.println("请录入年龄");
            int age = sc.nextInt();
            Student student = new Student(name,age);
            list.add(student);
        }
    }
    public static void Pintlist(ArrayList<Student> list)
    {
        for(Student i:list)
        {
            System.out.println("姓名是"+i.getname()+",年龄是"+i.getage());
        }
    }
    public static void randomstudent(ArrayList<Student> list)
    {
        int i = new Random().nextInt(list.size());
        System.out.println("中奖劳斯莱斯的姓名是"+list.get(i).getname()+",年龄是"+list.get(i).getage());    }
}

####代码6:最基本 的继承方法调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package day3;

public class demo1 {
    public static void main(String [] args)
    {
        algo name = new algo();
        name.name = "小明";
        name.get_name();
        name.work();
    }

}

class Employee{
    String name;
    public void work()
    {
        System.out.println("在工作");
    }
}

class algo extends Employee{
    public void get_name()
    {
        System.out.println("姓名是:"+name);
    }
}

代码7:子类调用父类同名属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class demo2 {
    public static void main(String [] args)
    {
        algo2 al = new algo2();
        al.print_();
    }



}

class eploee{
    String name = "小明";
}

class algo2 extends eploee{
    String name = "小志";
    public void print_()
    {
        System.out.println(this.name);
        System.out.println(super.name); //同名调用父类的属性
    }
}

#####代码8:方法的重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package day3;

public class demo2 {
    public static void main(String [] args)
    {
        algo2 al = new algo2();
        al.print_();
    }
}

class eploee{
    String name = "小明";
    public void print_(){
        System.out.println(this.name);
    }
}

class algo2 extends eploee{
    String name = "小志";
    public void print_()
    {
        System.out.println(this.name);  //输出小志
        eploee el = new eploee();
        el.print_();
    }
}

//通常是为了扩展功能,或者该方法不符合需求了,但是不能在原方法上修改,避免引起一系列反应

####代码9:方法覆盖手机案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package day3;
//    a:案例:比如手机，当描述一个手机时，它具有发短信，打电话，显示来电号码功能，
//            后期由于手机需要在来电显示功能中增加显示姓名和头像，
//            这时可以重新定义一个类描述智能手机，并继承原有描述手机的类。
//            并在新定义的类中覆盖来电显示功能，在其中增加显示姓名和头像功能
public class demo {
public static void main(String [] args)
{
    new_phone phone = new new_phone();
    phone.show();
}
}
class Phone{
    public void send(){
        System.out.println("发短信");
    }
    public void call()
    {
        System.out.println("打电话");
    }
    public void show(){
        System.out.println("显示号码");
    }
}

class new_phone extends Phone{
    //扩展
    public void show(){
        System.out.println("显示号码:显示头像:显示姓名");
    }
}

//注意:方法覆盖,子类中的方法权限必须大于父类,如上show方法,new_phone必须是public否则报错
权限:public >默认=protected>private
 b:方法定义:子类方法和要重写的父类的方法:方法的方法名和参数列表都要一样。
   关于方法的返回值:
     如果是基本数据类型,子类的方法和重写的父类的方法返回值类型必须相同
     如果是引用数据类型,子类的方法和重写的父类的方法返回值类型可以相同或者子类方法的返回值类型是父类方法返回值类型的子类

代码10:初识抽象类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package day3;

public class demo3 {
    public static void main(String [] args)
    {
        new android().work();
        new algo3().work();
    }
}

abstract class Develop{
    public abstract void work();//抽象类没法确定主体方法内容
}

class android extends Develop{  //子类必须重载抽象类中的方法
    public void work(){
        System.out.println("你奶奶的");
    }
}

class algo3 extends Develop{
    public void work(){
        System.out.println("你妹的");
    }
}

//抽象类和抽象方法都需要被abstract修饰。抽象方法一定要定义在抽象类中。
//抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
//抽象类的作用:继承的体系抽象类,强制子类重写抽象的方法
//抽象类下要也可以创建方法和对应的主体,但没有什么实际意义,可调用

####代码11:员工类(this)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package day3;

public class demo4 {
    public static void main(String [] args)
    {
        javaee java = new javaee("小明",66);
        java.work();
    }
}


abstract class Employee2{
    private String name;
    private int id;

    public Employee2(String name, int id)
    {
     this.id =  id;
     this.name = name;
    }

    public String get_name()
    {
        return this.name;

    }
    public int get_id()
    {
        return this.id;
    }

    public abstract void work();
}

class javaee extends Employee2{
    public javaee(String name, int id) {
        super(name, id);
    }
    public void work()
    {
        System.out.println("JavaEE的工程师开发淘宝"+ super.get_name()+".."+super.get_id());
    }
}

####代码12:员工类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package day3;

public class demo5 {
    public static  void main (String [] agrs)
    {
        javaee2 java =   new javaee2();
        java.setName("小明");
        java.setId(66);
        java.work();

        ceshi ceshi_ = new ceshi();
        ceshi_.setId(99);
        ceshi_.setName("笑话");
        ceshi_.work();

    }

}

abstract class employee{
    private String name;
    private int id;
    //存取名字id
    public  void setName(String name)
    {
        this.name = name;
    }
    public void setId(int id)
    {
        this.id = id;
    }
    public int getid()
    {
        return this.id;
    }
    public String getname()
    {
        return this.name;
    }
    public abstract void work();
}

abstract class Develop2 extends employee{ }

abstract class Mainter extends employee{ }

class javaee2 extends Develop2
{
    public void work(){
        System.out.println("JAVA员工"+getname()+"id"+getid());
    }
}

class ceshi extends Mainter
{
    public void work(){
        System.out.println("测试员工"+getname()+"id"+getid());
    }
}

####代码13:犬和缉毒功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package day4;
//接口和抽象类:抽象类是对类的抽象,即单一的类无法描述所有情况的时候,而接口是一种扩展的功能,不是所有都使用
//一个类智能继承一个父类,但是可以继承多个接口
public class demo1 {
    public static void main(String [] args)
    {
        home_dog dog = new home_dog();
        dog.laugh();
        dog.eat();
        dog.drug_();
    }
}

//犬和缉毒
//犬定义为抽象类
abstract class dog{
    public abstract void laugh();
    public abstract void eat();
}

//缉毒
interface drug{
    public void drug_();
}

class home_dog extends dog implements drug
{
    public void drug_()
    {
        System.out.println("狗会缉毒");
    }
    public void laugh() {
    System.out.println("家园狗大脚");
    }

    public void eat() {
        System.out.println("吃牛肉");
    }
}

代码14:多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package day4;
//调用属性时使用的是父类的,调用方法编译时使用的是父类,执行时使用的是子类,因为被重载了
public class demo2 {
    public static void main(String [] args)
    {
        Fu fu = new Zi();
        System.out.println(fu.num);
        fu.get_num();
        Zi zi = new Zi();
        System.out.println(zi.num);
        zi.get_num();
    }
}

class Fu{
    int num = 3;
    public void get_num()
    {
        System.out.println("数字是"+num);
    }
}

class Zi extends Fu
{
    int num = 6;
    public void get_num()
    {
        System.out.println("数字是"+num);
    }
}

####代码15:向上转型和向下转型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//向上转型:将子类对象转换成父类对象.可以调用父类的属性和子类的方法(都有的,会重载,子类中独有的无法调用,会报错)
//向下转型:父类对象转为子类对象====前提是向上转型,否则会报错

////////////////////////////////////向上转型
package day4;

public class demo3 {
    public static void main(String [] args)
    {
        Animal animal = new dog2();
        System.out.println(animal.age);
        animal.eat();
        animal.work();//baocuo
    }
}

class Animal{
    int age = 20;
    public void eat(){
        System.out.println("chifan");
    }
    public void work()
    {
        System.out.println("kaisgongzuossss");
    }
}

class dog2 extends Animal
{
    int age = 10;
    public void eat(){
        System.out.println("chifansssss");
    }
}

////////////////////////////////////向下转型

####代码16:笔记本电脑案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package day7;

interface USB{
    void open();
    void close();
}

//鼠标空值
class Mouse implements USB{
    public void open(){
    System.out.println("鼠标开启");
    }
    public void close(){
        System.out.println("鼠标关闭");
    }
}

//键盘控住
class keyboard implements USB{
    public void open(){
        System.out.println("键盘开启");
    }
    public void close(){
        System.out.println("键盘关闭");
    }
}

//笔记本
class Notebook{
    public void run(){
        System.out.println("开启笔记本");
    }

    public void useusb(USB usb)
    {
        if (usb != null){
            usb.open();
            usb.close();
        }
    }

    public void shut(){
        System.out.println("笔记本关闭");
    }
}


public class demo {
    public static void main(String [] args)
    {
        Notebook note = new Notebook();
        note.run();
        keyboard ky = new keyboard();
        note.useusb(ky);
        Mouse mu = new Mouse();
        note.useusb(mu);
        note.shut();
    }
}

代码17:this构造方法的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
//局部变量和成员变量
public class demo3 {
    private String name;
    private int age;
    public static void main(String [] args){
        demo3 de = new demo3("小明",26);
        de.get_name_age();
    }
    //构造方法
    public demo3(String na){
        name = na;
    }
    //构造方法this,this指代当前对象
    public demo3(String na,int ag)
    {
        this(na);  //指代的就是创建的对象
        age = ag;
    }
    public void get_name_age(){
        System.out.println("姓名是"+name+"年纪是"+age);
    }
}


##进一步,数值比较

public class demo4 {
    private String name;
    private int age;
    public static void main(String [] args){
        demo4 de = new demo4("小明",26);
        de.get_name_age();
        demo4 de2 = new demo4("小明",26);
        System.out.println("是否同岁:"+de.judge_age(de2));
    }
    //构造方法
    public demo4(String na){
        name = na;
    }
    //构造方法this,this指代当前对象
    public demo4(String na,int ag)
    {
        this(na);  //指代的就是创建的对象
        age = ag;
    }
    public void get_name_age(){
        System.out.println("姓名是"+name+"年纪是"+age);
    }
    public boolean judge_age(demo4 d){
        return this.age == d.age;
    }
}

##构造方法继承时候自动调用父类
package day9;

//继承的构造方法:会自动调用父类的,有个隐式的super执行
public class demo1 {
    public static void main(String [] args){
        new Zi();
    }
}


class Fu{
    int num;
    public Fu(){
        System.out.println("到爸爸这来");
        num = 2;
    }
}

class Zi extends Fu{
    public Zi(){
        //有个隐式super
        System.out.println(num);
    }
}

代码18:综合案例—完整的员工类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
public class demo2 {
    public static void main(String [] args){
        JavaEE ja = new JavaEE("小米",25);
        ja.work();
        JavaEE ja2 = new JavaEE();
        ja2.set_age(20);
        ja2.set_name("笑话");
        ja2.work();
    }
}
//工人类
abstract class Employee{
    private String name = "四大神兽多所";
    private int age = 26;
    //无参数构造
    public Employee(){
        super();
    }
    //含参
    public Employee(String name,int age){
        this.name = name;
        this.age = age;
    }
    //获取姓名
    public String get_name(){
        return name;
    }
    //设置姓名
    public void set_name(String name){
        this.name = name;
    }
    //获取年龄
    public int get_age(){
        return age;
    }
    //设置年龄
    public void set_age(int age){
        this.age = age;
    }
    //抽象类工作
    public abstract void work();
}

//研发类
abstract class Develop extends Employee{
    public Develop(){
        super();
    }
    public Develop(String name,int age){
        super(name,age);
    }
}

//测试类
abstract class Test extends Employee{

    public Test(String name,int age){
        super(name,age);
    }
}

class JavaEE extends Develop{
    @Override
    public void work() {
        System.out.println("java员工"+get_name()+"年龄"+get_age());
    }
    public JavaEE(String name,int age){
        super(name,age);
    }
    public JavaEE(){
        super();
    }
}

//以此类推

code19.内部类的的访问及定义

1
2
3
4
5
6
7
8
9
10
11
12
13

public class demo4 {
    public static void main(String [] args){
        body.heart h = new body().new heart();
        System.out.println(h.name);
    }
}

class body{
    class heart{
        String name = "心脏";
    }
}

code20.打牌

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

/*
 * 斗地主洗牌发牌排序
 */
public class Poker {

	public static void main(String[] args) {

		//准备花色
		ArrayList<String> color = new ArrayList<String>();
		color.add("♠");
		color.add("♥");
		color.add("♦");
		color.add("♣");
		
		//准备数字
		ArrayList<String> number = new ArrayList<String>();
Collections.addAll(number,"3","4","5","6","7","8","9","10","J","Q","K","A","2");
		
		//定义一个map集合：用来将数字与每一张牌进行对应
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		
		int index = 0;
		for (String thisNumber : number) {
			for (String thisColor : color) {
				map.put(index++, thisColor+thisNumber);
			}
		}
		
		//加入大小王
		map.put(index++, "小☺");
		map.put(index++, "大☻");
		
		//一副54张的牌 ArrayList里边为0-53的数的新牌
		ArrayList<Integer> cards = new ArrayList<Integer>();
		
		for (int i = 0; i <= 53; i++) {
			cards.add(i);
		}
		
		//洗牌
		Collections.shuffle(cards);
		
		//创建三个玩家和底牌
		ArrayList<Integer> iPlayer = new ArrayList<Integer>();
		ArrayList<Integer> iPlayer2 = new ArrayList<Integer>();
		ArrayList<Integer> iPlayer3 = new ArrayList<Integer>();
		ArrayList<Integer> itCards = new ArrayList<Integer>();
		
		//遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和底牌中
		for (int i = 0; i < cards.size(); i++) {
			if(i>=51) {
				iCards.add(cards.get(i));
			} else {
				if(i%3==0) {
					iPlayer.add(cards.get(i));
				}else if(i%3==1) {
					iPlayer2.add(cards.get(i));
				}else {
					iPlayer3.add(cards.get(i));
				}
			}
		}
		
		//对每个人手中的牌排序
		Collections.sort(iPlayer);
		Collections.sort(iPlayer2);
		Collections.sort(iPlayer3);
		
		//对应数字形式的每个人手中的牌，定义字符串形式的牌
		ArrayList<String> sPlayer = new ArrayList<String>();
		ArrayList<String> sPlayer2 = new ArrayList<String>();
		ArrayList<String> sPlayer3 = new ArrayList<String>();
		ArrayList<String> sCards = new ArrayList<String>();
		
		for (Integer key : iPlayer) {
			sPlayer.add(map.get(key));
		}
		for (Integer key : iPlayer2) {
			sPlayer2.add(map.get(key));
		}
		for (Integer key : iPlayer3) {
			sPlayer3.add(map.get(key));
		}
		for (Integer key : iCards) {
			sCards.add(map.get(key));
		}
		
		//看牌
		System.out.println(sPlayer);
		System.out.println(sPlayer2);
		System.out.println(sPlayer3);
		System.out.println(sCards);
	}
}

code21:异常

1
2
3
4
5
6
7
8
9
package day11;

public class demo1 {

    public static void main(String [] args){int num = 2; try{ test(num); }catch (Exception e){System.out.println(test2(num));}}
    private static void test(int num) {int a = num/0; }
    private static int test2(int num) {int b;b = num/1;return b; }}

//try catch()

code22:加法运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public static void main(String[] args)
{
    
    System.out.println("请输入2个加数");
    int result;
    try
    {
        result = add();
        System.out.println("结果:"+result);
    } catch (Exception e){
        e.printStackTrace();
    }
}
//获取输入的2个整数返回
private static List<Integer> getInputNumbers()
{
    List<Integer> nums = new ArrayList<>();
    Scanner scan = new Scanner(System.in);
    try {
        int num1 = scan.nextInt();
        int num2 = scan.nextInt();
        nums.add(new Integer(num1));
        nums.add(new Integer(num2));
    }catch(InputMismatchException immExp){
        throw immExp;
    }finally {
        scan.close();
    }
    return nums;
}

//执行加法计算
private static int add() throws Exception
{
    int result;
    try {
        List<Integer> nums =getInputNumbers();
        result = nums.get(0)  + nums.get(1);
    }catch(InputMismatchException immExp){
        throw new Exception("计算失败",immExp);  /////////////////////////////链化:以一个异常对象为参数构造新的异常对象。
    }
    return  result;
}

集合框架下的List

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class listdemo {
    public static void main(String [] args){
        List<String> name_list = new ArrayList<String>();
        System.out.println(name_list.size());
        name_list.add("小米");//增
        name_list.add("小花");//增
        name_list.add(1,"小框");
        System.out.println(name_list.size());
        get_list(name_list);//获取元素
        name_list.remove("小米");
        get_list(name_list);
        name_list.remove(1);
        get_list(name_list);
        name_list.set(0,"小狗");
        get_list(name_list);
        System.out.println(name_list.get(0));
    }
    public static void get_list(List<String>  list){
        ListIterator<String> it =  list.listIterator();
        System.out.println(list.size());
        while (it.hasNext()){
            System.out.println(it.next());
            if(it.next().equals("小花")){
                list.add("小猪");
            }
        }
    }
}

//vector和arraylist区别(vector加enum别arraylist和itertoor替代)
import java.util.*;

public class listdemo2 {
    public static void main(String [] args){
        List<String> ls = new ArrayList<>();
        ls.add("小明");
        ls.add("小李");
        ls.add("三大大三");
        Iterator<String> it = ls.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        Vector<String> ls2 = new Vector<>();
        ls2.addElement("笑了");
        ls2.addElement("是打算");
        Enumeration<String> eu = ls2.elements();
        while(eu.hasMoreElements()){
            System.out.println(eu.nextElement());
        }
    }
}
hashset自定义元素
1
2


多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package day12;

public class demo {
    public static void main(String [] args){
        ThreadDemo td = new ThreadDemo();
        td.start();
//        td.run();
    }
}

class ThreadDemo extends Thread{
    public void run(){
        for(int i = 0;i<=10;i++){
            System.out.println(i);
        }
    }
}
//start表示启用多线程,run表示调用方法


//***************************方法2*********************************
package day12;

public class runnerable {
    public static void main(String [] args){
        run_demo run = new run_demo();
        Thread th = new Thread(run);
        th.start();
    }
}


class run_demo implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i<=10;i++){
            System.out.println(i);
        }
    }
}
线程池runnable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package day12;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class thread_pool {
    public static void main(String [] args){
        ExecutorService service = Executors.newFixedThreadPool(2);
        run_thread th = new run_thread();
        service.submit(th);
        service.shutdown();
    }
}

class run_thread implements Runnable{
    public void run(){
        for(int i = 0;i<=10;i++){
            System.out.println(i);
        }
    }
}
线程池callable
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package day12;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class callable_pool {
    public static void main(String [] args){
        ExecutorService service = Executors.newFixedThreadPool(2);
        call_pool cl = new call_pool();
        service.submit(cl);
        service.shutdown();
    }
}


class call_pool implements Callable{
    @Override
    public Object call() throws Exception {
        for(int i = 0;i<10;i++){
            System.out.println(i);
        }
        return null;
    }
}

线程池实现两个数相加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package day12;

import java.util.concurrent.*;

public class add_by_thread {
    public static void main(String [] args) throws ExecutionException, InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(2);
        call_func cl = new call_func(2,10);
        call_func cl2 = new call_func(20,10);
        Future<Integer> res = service.submit(cl);
        Future<Integer> res2 = service.submit(cl2);
        Integer data = res.get();
        System.out.println(data);
        Integer data2 = res2.get();
        System.out.println(data2);
        service.shutdown();


    }
}

class call_func implements Callable<Integer>{
    int x;
    int y;
    public call_func(int x,int y){
        this.x = x;
        this.y = y;
    }

    @Override
    public Integer call() throws Exception {
        return x+y;
    }
}
线程同步
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//线程不同步案例,线程不安全
package day12;

public class buy_ticket {
    public static  void main(String [] args){
    ticket t = new ticket();
    Thread t1 = new Thread(t,"窗口1");
    Thread t2 = new Thread(t,"窗口2");
    Thread t3 = new Thread(t,"窗口3");
    t1.start();
    t2.start();
    t3.start();
    }
}


class ticket implements Runnable{
    int ticket_num = 100;
    @Override
    public void run() {
    while(true){
        if (ticket_num>0){
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +"正在卖票"+ticket_num--);
        }
        }
    }
    }

//解决线程不安全问题
package day12;

public class buy_ticket {
    public static  void main(String [] args){
    ticket t = new ticket();
    Thread t1 = new Thread(t,"窗口1");
    Thread t2 = new Thread(t,"窗口2");
    Thread t3 = new Thread(t,"窗口3");
    t1.start();
    t2.start();
    t3.start();
    }
}


class ticket implements Runnable{
    int ticket_num = 100;
    Object lock = new Object();
    @Override
    public void run() {
    while(true){
        synchronized (lock){
        if (ticket_num>0){
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +"正在卖票"+ticket_num--);
        }
        }
    }
    }}
map reduce 案例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

/**
 * KEYIN ：是map task读取到的数据的key的类型，是一行的起始偏移量Long
 * VALUEIN:是map task读取到的数据的value的类型，是一行的内容String
 * 
 * KEYOUT：是用户的自定义map方法要返回的结果kv数据的key的类型，在wordcount逻辑中，我们需要返回的是单词String
 * VALUEOUT:是用户的自定义map方法要返回的结果kv数据的value的类型，在wordcount逻辑中，我们需要返回的是整数Integer
 * 
 * 
 * 但是，在mapreduce中，map产生的数据需要传输给reduce，需要进行序列化和反序列化，而jdk中的原生序列化机制产生的数据量比较冗余，就会导致数据在mapreduce运行过程中传输效率低下
 * 所以，hadoop专门设计了自己的序列化机制，那么，mapreduce中传输的数据类型就必须实现hadoop自己的序列化接口
 * 
 * hadoop为jdk中的常用基本类型Long String Integer Float等数据类型封住了自己的实现了hadoop序列化接口的类型：LongWritable,Text,IntWritable,FloatWritable
 * 
 * 
 * 
 * 
 * @author ThinkPad
 *
 */
public class WordcountMapper extends Mapper<LongWritable, Text, Text, IntWritable>{
    
    @Override
    protected void map(LongWritable key, Text value, Context context)
            throws IOException, InterruptedException {

        // 切单词
        String line = value.toString();
        String[] words = line.split(" ");
        for(String word:words){
            context.write(new Text(word), new IntWritable(1));
            
        }
    }
}


import java.io.IOException;
import java.util.Iterator;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

public class WordcountReducer extends Reducer<Text, IntWritable, Text, IntWritable>{
    
    
    @Override
    protected void reduce(Text key, Iterable<IntWritable> values,Context context) throws IOException, InterruptedException {
    
        
        int count = 0;
        
        Iterator<IntWritable> iterator = values.iterator();
        while(iterator.hasNext()){
            
            IntWritable value = iterator.next();
            count += value.get();
        }
        
        
        context.write(key, new IntWritable(count));
        
    }
    
    

}

代码100:api:object克隆

1
2
3
4
5
6
7
8
9
10
11
package day5;
/*object克隆*/
public class demo1 implements Cloneable{
    int i;
    public static void main(String [] args) throws Exception{
        demo1 dem = new demo1();
        dem.i  = 10;
        demo1 dem2 = (demo1) dem.clone();
        System.out.println(dem2.i);
    }
}