Java开发环境

• 编译运行过程：
  • 编译器：java源文件，经过编译，生成class字节码文件
  • 运行期：JVM加载class文件并运行
• JVM：java虚拟机
  • 堆：
    • new出来的对象（包括实例变量）
    • 垃圾：没有任何引用所指向的对象。垃圾回收期（GC）不定时到内存中清扫垃圾，回收过程是透明的，不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC回收
    • 实例变量的生命周期：
      • 创建对象时存储在堆中，对象被回收是一并被回收
      • 内存泄漏：不再使用的对象没有被及时的回收，严重的泄漏会导致系统的崩溃。建议：不再使用得对象应及时将引用设置为null
  • 栈：
    • 存储正在调用的方法中的局部变量（包括方法的参数）
    • 调用方法时，会在栈中为该方法分配一块对象的栈帧，栈帧中存储局部变量（包括方法的参数），方法调用结束时，栈帧被自动清除，局部变量一并被清除
    • 局部变量的生命周期：
      • 调用方法是存储在栈中，方法调用结束是与栈帧一并被清除
  • 方法区：
    • calss字节码文件（包括静态变量、所有方法）
    • 方法只有一份，通过this来区分具体的访问对象
• JRE：java运行环境
• JDK：java开发工具包

八种基本数据类型

• boolean -- 布尔型
• byte
• char -- 字符型
• short -- 短整型
• int -- 整型
• float -- 单精度浮点型
• long --长整型
• double -- 双精度浮点型

类型间的转换

• 自动（隐式）类型转换：小类型到大类型
• 强制类型转换：大类型到小类型
• 两点规则：
  • 整数直接量可以直接赋值给byte、short、char，但不能超出范围
  • byte、short、char型数据参与运算时，系统一律自动将其转换为int再做运算

运算符

• 算术：+，-，*，/，%，++，–
• 关系：>，<，>=，<=，==，!=
• 逻辑：&&，||，!
• 赋值：=，+=，-=，*=，/=，%=
• 字符串连接符：+
• 条件（三目）：(条件)?(true):(false)

分支结构

• if结构：1条路

• if…else结构：2条路

• if…else if结构：多条路

  • 语法

  if(boolean-1){
    语句块1
    }else if(boolean-2){
        语句块2
        }else if(boolean-3){
            语句块3
            }else{
                语句块4
                }
  

  • 执行过程

  判断boolean-1，若为true则执行语句块1(结束)，若为false则
  再判断boolean-2，若为true则执行语句块2(结束)，若为false则
  再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束) 
  

• switch...case结构

  • 优点：效率高、结构清晰
  • 缺点：只能对整数判断相等
  • break：跳出switch switch可以用于 byte,short,int,char,String,枚举类型

循环结构

• 循环：反复多次执行一段相同或相似的代码
• 循环三要素： 1.循环变量的初始化 2.循环的条件(以循环变量为基础) 3.循环变量的改变(向着循环的结束变)
• while结构：先判断后执行，有可能一次都不执行
• do…while结构：先执行后判断，至少执行一次
• for结构：应用率高、与次数相关的循环
• 增强for循环
  • JDK5之后推出的新特性
  • java编译器认可的
• 三种循环结构的选择规则：
  • 先看循环是否与次数相关：
    • 若相关-----直接上for
    • 若无关，再看要素1与要素3是否相同：
      • 若相同-----直接上do…while
      • 若不同-----直接上while
• break：跳出循环
• continue：跳过循环体中剩余语句而进入下一次循环
• 嵌套循环：
  • 循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
  • 执行过程：外层循环走一次，内层循环走所有次
  • 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
  • break只能跳出当前一层循环

方法

• 封装一段特定的业务逻辑功能
• 尽可能的独立，一个方法只干一件事
• 方法可以被反复多次调用
• 减少代码重复，有利于代码复用，有利于代码维护

定义方法：五要素

修饰词 返回值类型 方法名(参数列表) {undefined
 方法体--------------具体的业务逻辑功能实现
 }

调用方法

• 无返回值：方法名(有参传参);
• 有返回值：数据类型 变量 = 方法名(有参传参);

return

• return 值; //1)结束方法的执行 2)返回结果给调用方
• return; //1)结束方法的执行

数组

• 是一种数据类型(引用类型)
• 相同数据类型元素的集合
• 访问：访问的是数组中的元素
  • 通过(数组名.length)可以获取数组的长度(元素的个数)
  • 通过下标/索引来访问数组中的元素
• 遍历/迭代：从头到尾挨个走一遍
• 复制
  • System.arraycopy(a,1,b,0,4);
  • int[ ] b = Arrays.copyOf(a,6);
• 排序
  • Arrays.sort(arr); //升序排列(从小到大)
• 引用类型数组
  • 与基本类型数组的区别：
    • 给数组元素赋值必须new
    • 若想访问对象数据必须通过数组元素点

集合

集合与数组一样，可以保存一组元素，并且提供了操作元素的相关方法，使用更方便

• 集合只能存放引用类型元素，并且存放的是元素的引用（地址）

相关接口

• java.util.Collection

  是所有集合的顶级接口，有多种实现类

  • java.util.List

    线性表，可重复集合，有序 这里可重复指的是集合中的元素是否可以重复，而判定重复元素的标准是依靠元素自身equals比较的结果，为true就认为是重复元素

    • 常见实现类：
      • ArrayList：内部使用数组实现，查询性能更好
      • LinkedList：内部使用链表实现，首尾增删元素性能更好
    • 常见方法：
      • get(int index)：获取指定下标对应的元素
      • set(int index, E e)：将给定元素设置到指定位置，返回值为该位置原有的元素（替换元素操作）
      • add(int index,E e)：将给定的元素插入到指定位置
      • remove(int index)：删除并返回指定位置上的元素
      • subList(int start,int end)：获取当前集合中指定范围内的子集，两个参数为开始与结束的下标（含头不含尾）
      • int size()：返回当前集合的元素个数
      • boolean isEmpty()：判断当前集合是否为空集
      • clear()：清空集合

  • java.util.Set

    不可重复集合，大部分实现类是无序的

集合与元素equals方法相关的方法

• boolean contains(Object o)：判断当前集合是否包含给定元素
• remove()：从集合中删除给定元素。对于可以存放重复元素的集合而言，只删除一次

集合间的操作

集合提供了如取并集，删交集，判断包含子集等操作

• boolean addAll(Collection c)：将给定集合中的所有元素添加到当前集合中，集合发生改变返回true
• boolean containsAll(Collection c)：判断当前集合是否包含给定集合中的所有元素
• boolean removeAlle(Collection c)：删除当前集合中与给定集合中的共有元素

遍历

Collection提供了统一的遍历集合方式：迭代器模式

Iterator iteartor()：该方法会获取一个用于遍历当前集合元素的迭代器

java.util.Iterator接口

迭代器接口，定义了迭代器遍历集合的相关操作 不同的集合都实现了一个用于遍历自身元素的迭代器实现类，我们无需记住它们的名字，用多态的角度把它们看做为Iterator即可 迭代器遍历集合遵循的步骤为：问、取、删，其中删除元素不是必要操作

迭代器遍历过程中不得通过集合的方法增删元素

会抛出异常：ConcurrntModificationException remove()：迭代器的remove方法可以将通过next方法获取的元素从集合中删除

泛型

JDK5之后推出的新特性 泛型也称为参数化类型，允许我们在使用一个类是指定他当中属性，方法参数或返回值的类型

• 泛型在集合中被广泛使用，用来指定集合中的元素类型
• 有泛型支持的类在使用时若不指定法宁的具体类型则默认为Object

集合与数组的转换

集合转换为数组

• toArray()：将当前集合转换为一个数组

  重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并将集合元素存入后返回。

数组转换为list集合

• asList()：将数组转换为一个List集合

  对数组转换的集合进行元素操作就是对原数组对应的操作

集合的排序

• Collections.sort(List list)：对List集合进行自然排序

排序自定义类型

重载Collections.sort(List list,Comparator c)方法

public class SortListDemo2 {
    public static void main(String[] args) {
        List<Point> list = new ArrayList<>();
        list.add(new Point(1,2));
        list.add(new Point(97,88));
        list.add(new Point(7,6));
        list.add(new Point(9,9));
        list.add(new Point(5,4));
        list.add(new Point(2,3));

        System.out.println(list);
        /*
            Collections.sort(List list)在排序List集合时要求集合元素必须实现了
            Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
            大小的规则，从而进行元素间的比较后排序。否则编译不通过。

            侵入性:
            当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
            称为侵入性。侵入性不利于程序后期的维护，尽可能避免。
            compare:比较
         */
//        Collections.sort(list);

        //匿名内部类的形式创建一个比较器
//        Comparator<Point> com = new Comparator<Point>() {
//            @Override
//            /**
//             * 实现比较器接口后必须重写方法compare.
//             * 该方法用来定义参数o1与参数o2的比较大小规则
//             * 返回值用来表示o1与o2的大小关系
//             */
//            public int compare(Point o1, Point o2) {
//                int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
//                int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
//                return len1-len2;
//            }
//        };
//        Collections.sort(list,com);//回调模式

//        Collections.sort(list,new Comparator<Point>() {
//            public int compare(Point o1, Point o2) {
//                int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
//                int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
//                return len1-len2;
//            }
//        });

        Collections.sort(list,(o1,o2)->
                o1.getX() * o1.getX() + o1.getY() * o1.getY() -
                o2.getX() * o2.getX() - o2.getY() * o2.getY()
        );

        System.out.println(list);
    }
}

• 实际开发中，我们并不会让我们自己定义的类去实现Comparable接口，因为这对我们的程序有侵入性
• 侵入性：当我们调用某个API功能时，其要求我们为其修改其他额外的代码，这个现象就是侵入性，侵入性越强的API越不利于程序的后期可维护性，应当尽量避免

排序字符串

java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序需求时,同样可以临时提供一种比较规则来进行排序.

Map查找表

Map体现的结构是一个多行两列的表格，其中左列称为key，右列称为value

• Map总是成对保存数据，并且总是根据Key获取对应的value，因此我们可以将查询的对应条件作为key，查询的对应结果作为value，保存到Map中
• Map有一个要求，Key不允许重复，因此如果使用重复的key存入value，则是替换value操作

常用实现类

• java.util.HashMap：散列表，使用散列算法实现的Map，当今查询速度最快的数据接口
• java.util.TreeMap：使用二叉树实现的Map

遍历

支持四种遍历方式：

• Set ketset()：遍历所有的key
• Set<Entry> entrySet()：遍历所有的键值对，以一个Entry实例形式存入set集合后返回，每个实例用于便是Map中额一组键值对，常用方法：
  • getKey()
  • getValue
• Collection values()：遍历所有的value
• map.forEach((k,v)->System.out.println(k+":"+v));