漫漫Java学习路,第十四天

package cn.tedu.collection;
import org.junit.Test;
import java.util.Arrays;
//本类用于集合前的一些测试
public class Demo {
    @Test
    public void saveStudent(){
        Student s1 = new Student("河莉秀",26,'女');
        Student s2 = new Student("木村拓哉",29,'男');
        Student s3 = new Student("工藤静香",25,'女');
        Student[] s = new Student[3];
        s[0] = s1;
        s[1] = s2;
        s[2] = s3;
        System.out.println(Arrays.toString(s));
    }
    @Test
    public void testArrays(){
        int[] a = {1,2,3};
        int[] a2 = new int[3];
        a2[0] = 1;
        a2[1] = 2;
        a2[2] = 3;
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(a2));
    }
}

package cn.tedu.collection;

public class Student {
   String name;
   int age;
   char gender;
    public Student() {
        System.out.println("中午吃啥好");
    }
    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        System.out.println("下午吃啥好");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

package cn.tedu.collection;
import java.util.ArrayList;
import java.util.List;
//本类用于测试泛型的优点
public class TestGeneric1 {
    public static void main(String[] args) {
        /*1.泛型是怎么来的?-->集合想要模拟数组的数据类型检查*/
        String[] a = new String[5];
        a[2] = "楚人美";
        a[4] = "伽椰子";
        //数组的好处:在编译期检查数据的类型,如果不是要求的数据类型就会报错
//        a[0] = 1;
//        a[1] = 8.8;
//        a[3] = 'c';
        /*2.泛型通常结合着集合一起使用*/
        /*3.引入泛型--主要目的是想通过泛型来约束集合中的元素类型*/
        /*4.引入泛型的好处:可以把报错的时机提前,在编译期就报错,而不是运行后才抛出异常
        * 向集合中添加元素是,会先检查元素的数据类型,不是要求的类型就编译失败*/
        List list = new ArrayList();
        //没有泛型,数据类型根本没有约束--太自由
        list.add("汪汪");
        list.add(1);
        list.add(8.8);
        list.add('a');
        System.out.println(list);

        List<String> list2 = new ArrayList();
        list2.add("我是雷神托尔");
        list2.add("为了北方神的荣耀");
//        list2.add(1);
//        list2.add(1.1);
//        list2.add('c');
        System.out.println(list2);

        /*5.<type>--type的值应该如何写?
        * 需要查看集合要存放的数据类型是什么,根据类型来定义
        * 但注意:type必须是引用类型,不是基本类型*/
        List<Integer> list3 = new ArrayList();
        list3.add(100);
        list3.add(200);
        list3.add(300);
    }
}

package cn.tedu.collection;
//本类用于测试泛型的优点2
public class TestGeneric2 {
    public static void main(String[] args) {
        Integer[] a = {1,2,3,4,5,6,7,8,9,10};
        print(a);
        String[] b = {"鹿力大仙","虎力大仙","羊力大仙","青狮精","白象精","金翅大鹏王","孔雀大明王"};
        print(b);
        Double[] c = {6.0,6.6,6.66,6.666,6.6666};
        print(c);
    }
    /*1.泛型可以实现通用代码的编写,使用E表示元素的类型是Element类型
    * 2.泛型的语法要求:
    * 如果在方法上使用泛型,必须两处同时出现,一个是传入参数的类型
    * 一个是返回值类型前的泛型类型,表示这是一个泛型方法*/
    private static <E> void print(E[] e) {
        for(E ddd: e){
            System.out.println(ddd);
        }
    }

//    private static void print(Double[] n){
//        for(Double ccc: n){
//            System.out.println(ccc);
//        }
//    }
//    private static void print(String[] n){
//        for(String bbb: n){
//            System.out.println(bbb);
//        }
//    }
//    private static void print(Integer[] n){
//        for(int i = 0;i<n.length;i++){
//            System.out.println(n[i]);
//        }
//        /*高效for循环/foreach循环
//        * 好处:比普通for循环写法简便,并且效率还高
//        * 坏处:没有办法按照下标来操作值,只能从头到尾依次遍历
//        * 语法:for(2 3:1){循环体}
//        * 1号是要遍历的内容,2 3是每轮遍历到的具体元素的类型与名字*/
//        for(Integer aaa: n){
//            System.out.println(aaa);
//        }
//    }
}

package cn.tedu.collection2;
import com.sun.deploy.panel.JreTableModel;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;

//本类用于测试Collection接口
public class TestCollection2 {
    public static void main(String[] args) {
        //<Integer>是泛型,用来约束集合中的元素类型,不能是基本类型,必须是引用类型
        Collection<Integer> c = new ArrayList();

        c.add(100);
        c.add(200);
        c.add(300);
        c.add(400);
        c.add(500);

        System.out.println(c);//直接打印集合对象的名字,查看集合中存入的具体元素
        //c.clear();//清空集合
        //System.out.println(c);
        System.out.println(c.hashCode());//获取集合对象对应的哈希码值
        System.out.println(c.equals(200));//false,集合对象c与元素200不等
        System.out.println(c.contains(200));//true,判断集合是否包含指定元素200
        System.out.println(c.isEmpty());//false,判断集合是否为空
        System.out.println(c.remove(100));//删除集合中的指定元素100
        System.out.println(c);
        System.out.println(c.size());//4,获取集合中的元素个数
        Object[] array = c.toArray();//将指定集合转为数组Object[]
        System.out.println(Arrays.toString(array));

        Collection<Integer> c2 = new ArrayList<>();
        c2.add(2);
        c2.add(4);
        c2.add(5);
        System.out.println(c2);

        c.addAll(c2);//将c2集合的所有元素添加到c集合中
        System.out.println(c);
        System.out.println(c2);

        System.out.println(c.containsAll(c2));
        //true,判断c集合是否包含c2集合的所有元素

        c.retainAll(c2);//保留c集合中那些也属于c2集合的公共元素
        System.out.println(c);

        c.removeAll(c2);//删除c集合中属于c2集合的所有元素
        System.out.println(c);//[]

        /*迭代步骤
        * 1.获取集合对应的迭代器
        * 2.通过迭代器判断集合中是否有下一个元素可以迭代
        * 3.通过迭代器获取当前迭代到的元素*/
        Iterator<Integer> it = c2.iterator();
        while(it.hasNext()){//如果有下一个元素
            System.out.println(it.next());//打印本轮循环到的元素
        }
    }
}

package cn.tedu.collection2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
//本类用于测试List接口
public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("大力娃");
        list.add("千顺娃");
        list.add("头铁娃");
        list.add("喷火娃");
        list.add("吐水娃");
        list.add("隐身娃");
        list.add("小紫娃");
        System.out.println(list);
        //list.clear();
        //System.out.println(list);
        System.out.println(list.contains("喷火娃"));
        System.out.println(list.equals("吐水娃"));
        System.out.println(list.isEmpty());
        System.out.println(list.remove("隐身娃"));
        System.out.println(list.size());
        System.out.println(Arrays.toString(list.toArray()));//将集合转为数组

        /*List集合是有序的,所以可以根据索引来操作集合中的元素
        * 可以存放重复的数据*/
        list.add("小虎队");
        list.add(1,"许仙");//在指定的索引处添加元素
        list.add(6,"小虎队");
        System.out.println(list);

        System.out.println(list.indexOf("小虎队"));//6,获取元素第一次出现的下标
        System.out.println(list.lastIndexOf("小虎队"));//8,获取元素最后一次出现的下标

        System.out.println(list);
        list.remove(5);//根据索引删除元素
        System.out.println(list);

        System.out.println(list.get(3));//头铁娃,根据下标获取元素
        System.out.println(list.set(2,"蝎子莱莱"));//修改指定下标位置的元素为蝎子莱莱
        System.out.println(list);

        List<String> list2 = new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        list2.add("4");
        System.out.println(list2);
        list.addAll(list2);
        System.out.println(list);//默认将2集合的元素追加到1集合末尾
        list.addAll(1,list2);//指定下标,将2集合的所有元素添加到1集合中
        System.out.println(list);
    }
}

package cn.tedu.seri;
import java.io.Serializable;
//本类用于封装学生类,用作测试序列化的物料类
/*如果本类的对象想要被序列化输出,那么本类必须实现可序列化接口,否则会报错
* 报错信息:java.io.NotSerializableException:cn.tedu.seri.Student
* Serializable接口是一个空接口,里面一个方法也没有,作用是当做标志,标志这个类可以被序列化*/
public class Student implements Serializable {
    private static final long seriaVersionUID = 1L;
    private String name;
    private int age;
    private String addr;
    private char gender;

    public Student() {
        System.out.println("我什么都没有");
    }

    public Student(String name, int age, String addr, char gender) {
        this.name = name;
        this.age = age;
        this.addr = addr;
        this.gender = gender;
        System.out.println("你爱我像谁");
    }

    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 String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
    //重写toString方法来查看对象的类型+属性+属性值
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                ", gender=" + gender +
                '}';
    }
}

package cn.tedu.seri;
import java.io.*;

//本类用于测试序列化和反序列化
/*序列化:是指把程序中的Java对象,永久保存在磁盘中,相当于是写出的过程
* 方向:out,用到的流是:IbjectOutputStream
* 反序列化:是指把已经序列化在文件中保存的数据,读取/恢复到java程序中的过程
* 方向:in,用到的流是:ObjectInputStream*/
public class TestSerializable {
    public static void main(String[] args) {
        method1();//序列化
        method2();//反序列化
    }
    //序列化方法
    private static void method1() {
        ObjectOutputStream out = null;
        try{
            out = new ObjectOutputStream(
                    new java.io.FileOutputStream("E:\\ready\\2.txt"));
            Student obj = new Student(
                    "海绵宝宝",3,"大海里",'男');
                    out.writeObject(obj);
            System.out.println("序列化成功");
        }catch(Exception e){
            System.out.println("序列化失败");
             e.printStackTrace();
        }finally {
            try{
                out.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }

    }

    private static void method2() {
        ObjectInputStream in = null;
        try{
            in = new ObjectInputStream(
                    new FileInputStream("E:\\ready\\2.txt"));
            System.out.println(in.readObject());
            System.out.println("反序列化成功");
        }catch(Exception e){
            System.out.println("反序列化失败");
            e.printStackTrace();
        }finally {
            try{
                in.close();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

package cn.tedu.test;

public class Test1 {
    public static void main(String[] args) {
            objPoolTest();
        }

        public static void objPoolTest() {
            int i = 40;
            int i0 = 40;
            Integer i1 = 40;
            Integer i2 = 40;
            Integer i3 = 0;
            Integer i4 = new Integer(40);
            Integer i5 = new Integer(40);
            Integer i6 = new Integer(0);
            Double d1=1.0;
            Double d2=1.0;

            System.out.println("i=i0\t" + (i == i0));
            System.out.println("i1=i2\t" + (i1 == i2));
            System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));
            System.out.println("i4=i5\t" + (i4 == i5));
            System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));
            System.out.println("d1=d2\t" + (d1==d2));

            System.out.println();
        }
    }

package cn.tedu.test;
import java.util.Arrays;
import java.util.Scanner;
public class Test2 {
    public static void main(String[] args) {
        String s = new Scanner(System.in).nextLine();
        char[] ch = s.toCharArray();
        System.out.println(Arrays.toString(ch));
        char[] ch1 = new char[ch.length];
        int j=0;
        for (int i = 0; i <ch.length ; i++) {
            if(ch[i]>='0' && ch[i]<='9'){
                ch1[j] = ch[i];
                j++;
                System.out.println(ch1);
            }
        }
        Arrays.sort(ch1);
        System.out.println(ch1);
    }
}

package cn.tedu.test;
import java.lang.reflect.Array;
import java.util.List;
import java.util.Scanner;
public class Test3 {
    public static void main(String[] args) {
       String s = new Scanner(System.in).nextLine();
       char[] ch = s.toCharArray();
       char c = ch[0];
        for (int i = 0; i <ch.length ; i++) {
            if(ch[i] ==c){
                System.out.println(i);
            }
        }
    }
}

package cn.tedu.test;
import java.util.Scanner;
//打印菱形
/*题目：打印出如下图案（菱形）
  ###4
  ##3*5
  #2***6
  1*****7
  #2***6
  ##3*5
  ###4
 */
public class Test4 {
    public static void main(String[] args) {
        //1.提示用户输入要打印的行数
        System.out.println("请输入您要打印的星星的行数");
        //2.声明四个变量
        int i = new Scanner(System.in).nextInt();//2.1.接收用户输入的数值,用于控制轮数
        int j = i;//2.2.用于控制打印次数
        int k = 1;//2.3.最小边界
        int l = 2*i-1;//2.4.最大边界
        //3.外层循环控制打印轮数
        for(;i>0;i--){
            //4.内层循环打印星数,将空白字符实体化进行打印
            for(int x=1;x<=j;x++) {
                //5.if语句判断要打印的是空白字符还是"*"号
                /*解析判断语句:
                * 单独看判断语句 x<i; x++; i-- 打印的是左侧上宽下窄的直角三角形
                * 判断语句 x<k; x++; k++ 打印的是左侧上窄下宽的直角三角形
                * 而 x>l; x++; l-- 打印的右侧上窄下宽的直角三角形
                * 当然,他们的判断标准需要用双或(||)来连接,否则你得到的就是两个小三角了
                * 而这三个直角三角形用空白字符打印后,在他们的留白部分用"*"打印
                * 我们便可以得到一个菱形*/
                if(x<i || x<k || x>l) {
                    System.out.print(" ");
                    //6.打印完空白字符后直接continue结束本轮内循环
                    continue;
                }
                //7.不符合判断条件时打印"*"号
                System.out.print("*");
            }
            //8.每轮将j的数值加1,同时将i的数值减1,便可得到一个正三角形
            j++;
            k++;
            l--;
            //9.每轮外循环换行一次
            System.out.println();
        }
    }
}