Java基础小知识

 类型转换、ASCII码、除法取余、三元表达式  

        long x = 100;//int->long自动类型转换（隐式) 1．特点:代码不需要进行特殊处理，自动完成。2．规则:数据范围从小到大。
        double y = 2.5F;//2.5 float->double自动类型转换（隐式)

        int x1 = (int)100L;//long->int强制类型转换（显式）  范围大到小  需要强转，不能自动转
        int y1 = (int)3.99;//double->int  抹去小数位变为3
        int z1 = (int)6000000000L;//long->int丢失精度  1705032704

        int charToInt = 'A'+1;//char->int
        int e = (byte)65+(byte)66;//byte->int byte取值-128~127
        int e1 = (byte)65+(short)66;//short取值范围-215~214;

        //ASCII码 '0'为48  'A'为65  'a'为97
        int charToInt2 = 'A'+0;//65 char底层保存的数字

        //除法与取余
        int r1 = 10/3;//3
        int r2 = 10%3;//1

        //三元表达式
        int a2 = 3>5? (int) 2.5:1;//冒号两侧都需符号精度要求

switch

    public static void main(String[] args) {
        int num  = 2;
        //匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。
        switch (num){
            case 1:
                System.out.println("你好");
            case 2:
                System.out.println("我好");
                //break；
            case 3:
                System.out.println("大家好");
                break;
            case 4:
                System.out.println("hello");
                break;
            default:
                System.out.println("hello~hello~hello~");
                break;
        }
    }

do-while()、while-do()、for循环

    public static void main(String[] args) {
        /*
        * do-while()和while-do()初始化语句参数出了循环后还可使用，但for循环初始化语句参数只能for循环内容使用
        * 若条件判断从来没满足过，do-while()也会执行1次，while-do()和for()不会执行
        * */
        System.out.println("=====================================");
        int i = 1;
        do {
            System.out.println("hello" + i);//循环体
            i++;//迭代语句，步进语句
        } while (i <= 10);//条件判断
        System.out.println("======================================");
        int x = 1;
        while (x<=10){
            System.out.println("xHello" + x);//循环体
            x++;//迭代语句，步进语句
        }
        System.out.println("======================================");
        for (int j = 1; j <=10 ; j++) {//迭代语句和变量定义在for循环参数里，只能当前for循环使用该参数
            System.out.println("jHello" + j);//循环体
        }
        /*
         * for循环的break和continue
         * */
        System.out.println("==========break=====================");
        for (int j = 1; j <=10 ; j++) {
            if (j==5){
                break;//如果j为5，跳出整个for循环，后续迭代都不要了
            }
            System.out.println("jHello" + j);
        }
        System.out.println("===========continue===================");
        for (int j = 1; j <=10 ; j++) {
            if (j==5){
                continue;//如果j为5，当次迭代的此处后续代码不执行了，马上开始下一个迭代继续执行for循环体
            }
            System.out.println("jHello" + j);/*jHello1 jHello2 jHello3 jHello4 jHello6 jHello7 jHello8 jHello9 jHello10*/
        }
    }

方法和return

/*
 * 方法： 1、方法定义于类中，方法中不可定义方法。2、类中方法无先后顺序。3、方法定义后需要(单独调用、打印调用、赋值调用)才能执行。
 * return：1、return的数据和方法返回值类型一致。2、void类型的方法可以不写return也可写为return;。
 * 方法中可多个return，要保证最终只有一个被执行到
 * */
public class JavaTest {
    public static int hello1() {
        return 10;
    }
    public static void hello2() {
        System.out.println("hello2");
    }
    public static void hello3() {
        int i = 2;
        if (i == 2) {
            System.out.println("hello2");
            return;
        } else {
            System.out.println("hello222");
        }
    }
}

方法重载

/*
 * 方法重载：方法名相同，参数类型或参数个数不同。对返回值类型没有要求。
 * 方法重载参数不一样。可以用来适配多种用户输入的数值类型提供的方法。 println()方法其实就是一个重载
 * */
public class JavaTest {
    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(1,2,3));
        System.out.println(sum("1",2));
        System.out.println(sum(1,"2"));
    }
    public static int sum(int a,int b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
    public static int sum(String a,int b){
        return Integer.valueOf(a)+b;
    }
    public static String sum(int a,String b){
        return String.valueOf(a+Integer.valueOf(b));
        //注：如果单返回值不同，但参数列表相同，也不是重载
    }
}

 访问权限修饰符

public（所有位置的类都可访问）、 protected（同包其他类、其他包该类的子类可访问）、

缺省不写（同包其他类可访问）、private（只能本类内部访问）

数组

/*
 * 数组：存放多个同一类型数据值的引用类型且运行期间长度不可变的容器
 * 动态初始化默认值：整数默认0、浮点型默认0.0、字符类型默认'\u0000'、布尔类型默认false、引用类型默认null；
 * 静态初始化也有默认值过程，只不过马上替换成大括号中的内容了。
 * 异常有下标0~arraA.length-1的数组索引越界异常ArrayIndexOutOfBoundsException，
 * 没有new数组直接如int [] a = null;a[0]的空指针异常NuLLPointerException。
 * 数组作为方法的参数或返回值其实传递进去的是地址值。
 * */
public class JavaTest {
    public static void main(String[] args) {
        //静态初始化
        int [] arrayA = new int[]{1,2,3};
        int [] arrayB = {1,2,3};
        System.out.println(arrayA);//地址值
        System.out.println(Arrays.toString(arrayB));//[1, 2, 3]
        System.out.println(arrayA[0]);
        int num2 = arrayB[2];System.out.println(num2);
        arrayB[0]=3;
        System.out.println(Arrays.toString(arrayB));//[3, 2, 3]
        //动态数组
        System.out.println("=====================");
        int [] arrC = new int[3];
        arrC[0] = 3;
        System.out.println(arrC[0]);
        System.out.println(arrC[1]);
        //遍历数组arrayA.fori
        for (int i = 0; i < arrayA.length; i++) {
            System.out.println(arrayA[i]);
        }
        //反转遍历数组arrayA.forr
        for (int i = arrayA.length - 1; i >= 0; i--) {
            System.out.println(arrayA[i]);
        }
    }
}

对象数组

com.kdy.domain包
public class Person {
    public String name;
    public Person(String name) {
        this.name = name;
    }
    public Person() {
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
com.kdy.test包
public class JavaTest {
    public static void main(String[] args) {
        Person[] array = new Person[3];
        Person zhangsan = new Person("zhangsan");
        Person wangwu = new Person("wangwu");
        Person sunwukong = new Person("sunwukong");
        array[0]=zhangsan;
        array[1]=wangwu;
        array[2]=sunwukong;
        System.out.println(Arrays.toString(array));
    }
}

 ArrayList数组

/*
 * ArrayList长度可变的集合，泛型为引用类型
 * list.add();添加；list.get(0);索引拿数组元素值；list.remove(0);索引删除；list.size();集合长度；
 * list.fori遍历集合
 * */
public class JavaTest {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("王五");
        list.add("王五1");
        list.add("王五2");
        System.out.println(list);//[王五]
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

Arrays类和Collections类

常用Arrays.toString(数组) 和 Arrays.sort(数组);   Arrays.asList("a","b","c")长度不可变的List

Collections.addAll(所有集合通用)——即集合名.allAll(集合名);

对于list集合有效：Collections.shuffle(poker);  Collections.sort(集合)排序     

com.kdy.domain

public class Person implements Comparable {
    private int id;
    private String name;
    private int age;
    public Person() {
    }
    public Person(int id, String name,int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Person o) {
        //return 0;//认为元素都是相同的
        //return this.id - o.id;//按id升序
        return this.age - o.age;//按年龄升序，年龄相同，list集合按存入先后顺序再排
        //return o.age - this.age;//按年龄降序
    }
}

public class Student {
    private int id;
    private String name;
    private int age;
    public Student() {
    }
    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    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;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

com.kdy.test 

public class JavaTest {
    public static void main(String[] args) throws ParseException {
     /*
     * 以ArrayList为例，学习Collections类
     * */
        ArrayList ArrayList = new ArrayList<>();
        HashSet hashSet = new HashSet<>();
        LinkedList linkedList = new LinkedList<>();
        LinkedHashSet linkedHashSet = new LinkedHashSet<>();
        Collections.addAll(ArrayList,"a","b","c","d","e","f","g");
        Collections.addAll(hashSet,"a","b","c","d","e","f","g");
        Collections.addAll(linkedList,"a","b","c","d","e","f","g");
        Collections.addAll(linkedHashSet,"a","b","c","d","e","f","g");
        System.out.println(ArrayList);//[a, b, c, d, e, f, g]
        System.out.println(hashSet);//[a, b, c, d, e, f, g]
        System.out.println(linkedList);//[a, b, c, d, e, f, g]
        System.out.println(linkedHashSet);//[a, b, c, d, e, f, g]
        Collections.shuffle(ArrayList);
        Collections.shuffle(linkedList);
        //Collections.shuffle(hashSet);//set集合无索引，无法打乱
        //Collections.shuffle(linkedHashSet);//set集合无索引，无法打乱
        System.out.println("shuffle后==========================");
        System.out.println(ArrayList);//[b, e, d, a, f, c, g]...
        System.out.println(linkedList);//[a, f, b, g, c, e, d]...
        Collections.sort(ArrayList);
        Collections.sort(linkedList);
        //Collections.sort(hashSet);//set集合无索引，不可根据大小排序
        //Collections.sort(linkedHashSet);//set集合无索引，不可根据大小排序
        System.out.println("sort后===================================");
        System.out.println(ArrayList);//[a, b, c, d, e, f, g]
        System.out.println(linkedList);//[a, b, c, d, e, f, g]
        /*想要使用Collections.sort()方法必须集合元素的类实现comparable<>接口，并重写接口中的方法*/
        java.util.ArrayList personArrayList = new ArrayList<>();
        personArrayList.add(new Person(3,"张678w41",23));
        personArrayList.add(new Person(2,"张375342",20));
        personArrayList.add(new Person(3,"张34576433",26));
        personArrayList.add(new Person(1,"张324552",23));
        personArrayList.add(new Person(5,"张34567435",25));
        Collections.sort(personArrayList);
        System.out.println(personArrayList);
        /*想要使用Collections.sort()方法也可也可以Collections.list()比较时使用匿名对象comparator，里面重写排序方法*/
        java.util.ArrayList studentList = new ArrayList<>();
        studentList.add(new Student(3,"张678w41",23));
        studentList.add(new Student(2,"张375342",20));
        studentList.add(new Student(3,"张34576433",26));
        studentList.add(new Student(1,"张324552",23));
        studentList.add(new Student(5,"张34567435",25));
        Collections.sort(studentList, new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                int result =  o1.getAge()-o2.getAge();
                if (result==0){
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(studentList);
    }
}

 Collection集合、List集合、Set集合

顶层：Collcetion接口（定义所有单列集合共享方法，没有带索引的方法）

List接口继承了Collection接口：有序【存取元素顺序相同】、允许元素重复、有索引

Set接口继承了Collection接口：不允许元素重复、无索引

Vector集合实现了List接口：先作了解。

ArrayList集合实现了List接口：底层数组可扩容，有下标，随机访问效率高，尾部增删正常，但越往头部增删越慢(因为得移动批量元素到上一个或下一个索引)，扩容时新建复制也耗时,需连续内存空间，开销小一些(只需新建或扩容时数组空间用不了可能)。

LinkedList实现类List接口：底层无头节点的双链表，增删快，随机访问越往后越慢(链表得一个个的履)，不需要连续内存空间，开销大一些(节点需保存信息还要保存前后节点的地址值)

TreeSet：继承了AbstractSet(实现了Set接口)，先作了解。

HashSet：实现了Set接口，无序(（对于存放的顺序而言，读取的顺序是无序的），底层哈希表查询非常快，jdk1.8前采用数组加链表，jdk1.8后的哈希表又采用了数组加链表或数组加红黑树（链表长度超过8自动转为红黑树）的形式提高了查询速度—非常快。

LinkedHashSet：实现了Set接口，且继承了HashSet，有序（对于存放的顺序而言，读取的顺序是无序的)）。

Collection方法 、Iterator、foreach、list、set

com.kdy.test 

public class JavaTest {
    public static void main(String[] args) throws ParseException {
        /*
         * 以Collection接口的子接口List接口的实现类ArrayList为例看Collection接口抽象方法
         * add、clear、remove、isEmpty、size、toArray
         * */
        ArrayList list = new ArrayList<>();
        list.add("abc");//添加add()
        list.add("def");
        list.clear();//清空clear()
        list.add("abc");
        list.add("def");
        boolean flag = list.remove("def");//移除元素remove()
        System.out.println(list.isEmpty());//判断集合是否为空isEmpty()
        int size = list.size();//集合元素个数size()
        Object[] objects = list.toArray();//集合转数组toArray()
        /*
         * List接口特有方法如下set和get
         * */
        list.set(0,"替换的元素");//用元素替换某个下标的元素
        list.get(0);//通过索引获取元素
        /*
         * Iterator遍历集合的方式
         * Collection接口返回Iterator对象的方法iterator()
         * */
        Iterator iterator = list.iterator();//将集合元素放入迭代器中
        while (iterator.hasNext()){//判断指针后一个有无元素
            String str = iterator.next();//后移指针，取出元素。
            System.out.println(str);
        }
        /*
         * 增强for
         * */
        for (String str :list) {
            System.out.println(str);
        }
        /*
         * LinkedList为例看Collection接口抽象方法
         * */
        LinkedList linkedList = new LinkedList<>();
        linkedList.add("abc");//添加add()
        linkedList.add("def");
        linkedList.clear();//清空clear()
        linkedList.add("abc");
        linkedList.add("def");
        boolean flag2 = linkedList.remove("def");//移除元素remove()
        System.out.println(linkedList.isEmpty());//判断集合是否为空isEmpty()
        int size2 = linkedList.size();//集合元素个数size()
        Object[] objects2 = linkedList.toArray();//集合转数组toArray()
        /*
         * LinkedList特有的方法
         * */
        linkedList.addFirst("helloFirst");//插入到第头个
        linkedList.addLast("lastHello");//插入到最后一个
        System.out.println(linkedList);//[helloFirst, abc, lastHello]
        linkedList.push("hello");// 推入栈顶 头节点
        System.out.println(linkedList);//[hello, helloFirst, abc, lastHello]
        String pop = linkedList.pop();//从栈顶弹出，弹出头节点移除并返回
        System.out.println(pop);//hello
        System.out.println(linkedList);//[helloFirst, abc, lastHello]
        String removeFirst = linkedList.removeFirst();//返回值为被移除的元素
        linkedList.removeLast();//返回值为被移除的元素
        /*
        * hashCode
        * 普通对象继承object重写了hashCode方法  460141958
        * String类重写了Object的hashCode方法，不过"通话"和"重地"的hash值重复
        * */
        Person person = new Person();
        System.out.println(person.hashCode());// 460141958
        System.out.println("通话".hashCode());//1179395
        System.out.println("重地".hashCode());//1179395
        System.out.println(System.identityHashCode("通话"));//1163157884
        System.out.println(System.identityHashCode("重地"));//1956725890
        System.out.println("通话".hashCode()=="重地".hashCode());//true ：哈希冲突了
        System.out.println("通话".equals("重地"));//false：使用的String的重写的equals方法：详见String类的equals方法
        System.out.println("通话"=="重地");//false：地址值不同，字符串常量池中还是不是一个地址
        /*
        * hashSet集合
        * hashSet采用了数组加链表或数组加红黑树的方式，它的算法是先判断当前元素hash值是否集合中存在，不存在就直接放数组，存在就再比较equals，相等就不替换，不相等就该数组该同等hash值的索引作为头节点，接入该节点作为链表中下一个节点
        *
        * */
        HashSet hashSet = new HashSet<>();
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add("abc");
        //s1和s2和"abc"：地址值不同、HashCode相同、toString如果是String不重写toString的话打印的内容也相同，重写的equals也相等
        hashSet.add("通话");
        hashSet.add("重地");
        System.out.println(hashSet);//[通话, 重地, abc]
        //创建hashSet存储Person
        HashSet set = new HashSet<>();
        set.add(new Person(1,"张三",20));
        set.add(new Person(2,"张三",20));
        set.add(new Person(1,"张三",20));
        //System.out.println(set);//如果Person不重写equals方法 [Person{id=2, name='张三', age=20}, Person{id=1, name='张三', age=20}, Person{id=1, name='张三', age=20}]
        System.out.println(set);// 如果Person重写了equals方法和hashCode方法  [Person{id=2, name='张三', age=20}, Person{id=1, name='张三', age=20}]
        /*集合中的泛型
         * 使用泛型可将运行期间的异常提升到编译期
         * 避免了类型转换时可能出现的异常，存放的是什么类型，取出时就是什么类型
         * */
        ArrayList