JavaSE基础部分--（一）

Week 1 #

7/25/2015 12:33:27 PM 

编程是魔法，我就是魔法师

---

java的开始

第一个java程序：**写完代码要保存
    ①：java代码文件是以  .java结尾的
    ②：class 类名{
                主函数(){//一个程序的入口
                        //函数体
                }
        }
    ③编译：将程序员写的java代码翻译成java虚拟机所能运行的文件.class
        格式：javac  文件名.java
                a)让cmd窗口找到java代码所在的位置
                    cd：搜索并进入某个目录(当前盘符下的某个目录)
                    （让光标和代码在同一个目录下）
    ④运行：运行编译生成的.class文件
        格式：java    .class文件名(不加.class)
注释：
    程序员改代码添加的说明（注释不属于代码的一部分）
        单行注释：   //
        多行注释：   /*   ....   */
                            /** ....    */---用来抽取javadoc文档
命名习惯：
    一般命名：单词首字母小写，后面每个单词首字母大写
    类名：       类名首字母必须大写     Hello
        类名中尽量不要包含   %  $  &  #  @  

---

二、输入输出流

### 标准输入流语句： 
    java.util.Scanner input = new java.util.Scanner(System.in);     // 准备接收控制台信息
    int bianliang = input.next();                                   // 控制台输入的数值
### 标准输出流语句： 
    System.out.println();                                           // 打印控制台输入的信息
### 当一次Scanner输入结束时，加一条语句： 
    input.close();                                                  // 关闭输入流

---

三、数据类型

### 基本数据类型：8种 
    byte    (1)     -128~127                                                               
    short   (2)     -2十五次方~2十五次方-1                                     
    int     (4)     -2六十三次方~2六十三次方-1                               
    long    (8)                                 10L                                             
    float   (4)     单精度浮点数                  10.0F
    double  (8)     双精度浮点数                  10.0        
    boolean         true | false        
    char                                        'A'     '9'     
### 复杂数据类型：（对象类型）
    String  双引号引起来的多个字符                 "ABC"   "100"
    ...

---

四、大整值（精度）

1 import java.math.BigDecimal;      // 引用java.math包中的BigInteger与BigDecimal类
2 符号的替换
    当使用大数值的时候，常用的不能用的 + — * / %,改为add、subtract、multiply、divide、、mod、abs等
3 大数值的赋值
        BigDecimal a = new BigDecimal(55);
4 四舍五入 （保留三位小数）
    System.out.println(a.divide(new BigDecimal(3),3,RoundingMode.HALF_UP));
  四舍五不入
    System.out.println(a.add(b).add(c).divide(new BigDecimal(3),3,RoundingMode.Down));
5 static BigInteger valueOf（long x）
6大数值的比较
    BigInter.compareTo( BigInter other),返回 -1，0,1
    BigInter.equals( BigInter other)，返回true，false
7 大数值转化为int型
    BigDecimal..IntValue();
8 大数值转化为double型
    BigDecimal.Ten.doubleValue(); 
9 保留2位小数
    double f1 = new BigDecimal(b).setScale(2,RoundingMode.HALF_UP).doubleValue(); 

---

五、循环（for）

### return语句，结束当前函数

### 乘法口诀表(for循环的应用） 
    for(int i=1;i<=9;i++){
        for(int j=1;j<=i;j++){
            System.out.print(j+" * "+i+" = "+i*j+"\t");
        }
        System.out.println();
    }

### 菱形的两种输入方式 
1  输入总最大行数：

    public static void main(String[] args) {

        // 输入的是总行数
        Scanner input = new Scanner(System.in);
        int lineSize = input.nextInt();
        lineSize = (lineSize + 1) / 2;

        // 上三角
        for(int i = 1;i <= lineSize;i++){
            for(int j = lineSize;j > i;j--){
                System.out.print(" ");
            }
            for(int j = 1;j <= 2 * i - 1;j++){
                System.out.print("*");
            }
            System.out.println();
        }
        // 下三角
        for(int i = lineSize - 1;i >= 1;i--){
            for(int j = lineSize;j > i;j--){
                System.out.print(" ");
            }
            for(int j = 1;j <= 2 * i - 1;j++){
                System.out.print("*");
            }
            System.out.println();
        }

    }

    ### 2  输入最中间一行的菱形数量 

    public static void main(String[] args) {
        System.out.print("请输入奇数数值：");
        Scanner input = new Scanner(System.in);
        int maxValue = input.nextInt();

        //偶数进入下一条循环，否则重复输入
        while (maxValue % 2 == 0) {
            System.out.print("请输入奇数数值：");
            maxValue = input.nextInt();
        }
        input.close();

        for (int i = 1; i <= maxValue; i++) {
            //偶数则继续下一条循环
            if (i % 2 == 0) {
                continue;
            }
            //计算且打印空格
            int spaceSize = (maxValue - i) / 2;
            for (int s = 0; s < spaceSize; s++) {
                System.out.print(" ");
            }
            //打印*
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = (maxValue - 1); i >= 0; i--) {
            //偶数则继续下一条循环
            if (i % 2 == 0) {
                continue;
            }
            //计算且打印空格
            int spaceSize = (maxValue - i) / 2;
            for (int s = 0; s < spaceSize; s++) {
                System.out.print(" ");
            }
            //打印*
            for (int j = 0; j < i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

---

六、字符串的应用

### 1. 比较的四种方式 **A.equals(B)** **A.equalsIgnoreCase(B)** **A.endsWith(B)** **A.startWith(B)**

    public static void main(String[] args) {
    String strOne = "abc";
    String strTwo = "bc";
    //对比
    if(strOne.equals(strTwo)){
        System.out.println("Eql");
    }else{
        System.out.println("NoEql");
    }

    //不区分大小写的比较
    if(strOne.equalsIgnoreCase(strTwo)){
        System.out.println("Eql");
    }else{
        System.out.println("NoEql");
    }


    //A endsWith B是A是否以B结尾
    if(strOne.endsWith(strTwo)){
        System.out.println("Ture");
    }else{
        System.out.println("False");
    }

    //startsWith A是否以B结尾
    if(strOne.startsWith(strTwo)){
        System.out.println("Ture");
    }else{
        System.out.println("False");
    }   

}`

### 2.**.toUpperCase()** **.toLowerCase()** **.substring(0,5)** 
###   **.substring(5))** **.length()**      **.charAt(i)**
###   ** trim() **去两边空格                 ** replace() ** 替换


    public static void main(String[] args) {

        String str = "My Apple";

        //将字符串转换为大写字母，并打印到控制台上
        System.out.println(str.toUpperCase());

        //将字符串转换为小写字母，并打印到控制台上
        System.out.println(str.toLowerCase());

        //截取字符串前五位
        System.out.println(str.substring(0,5));

        //截取字符串五位后的数
        System.out.println(str.substring(5));

        //计算长度
        System.out.println(str.length());

        //把数转为char值
        for(int i = 0;i < str.length();i++){
            char target = str.charAt(i);
            System.out.println(target);
        }   
    }

### ==和equals的区别 ###
    String str1 = new String("Hello");
    String str2 = new String("Hello");
    System.out.println(str1.equals(str2));
    System.out.println(str1 == str2);

    返回结果是true和false
    == 比较的是地址
    equals比较的是值

### ValueOf 和 parstInt区别 ###
    Integer.valueOf()方法重载了。他有三种参数，int，String，（String，int）。
    Integer.valueOf() 方法里调用了 Integer.parstInt()方法。

### String,StringBuilder,StringBufferr区别 ###

    string对象是不可变的，任何对String的改变都 会引发新的String对象的生成

    StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，如下就是，可知这两种对象都是可变的。    
    StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。
    StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。

    如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer

    StringBuffer s = new StringBuffer();
        public StringBuffer append(String b)
        public StringBuffer insert(int offset, boolean b)
        public StringBuffer deleteCharAt(int index)

---

七、未达目标重复输入

    //用while防止输入的数字不是四位
    System.out.print("请输入会员号<四位整数>：");      
    int num = input.nextInt();
    iput.close;
    while(num < 1000||num > 9999){
        System.out.print("请输入会员号<四位整数>：");  
        num = input.nextInt();
    }

---

八、流程控制

if
    if(逻辑条件){
        只有当条件为真时，才会执行的代码
    }

    if(条件){
        条件满足执行的代码
    }else{
        //当不满足条件时执行
    }


switch-case     （int，byte，short，char）
    switch(整型表达式){
        case 值1：
            //...
            break;
        case 值2：
            //。。
            break;
        ...
        default:
            //。。
    }

---

九、方法

###  方法建立

方法名首字母小写，且尽量不要用简写单词，表意清晰
减少冗余代码，一组具有特定功能的代码
例子：
    写一个函数：
    public static 返回值类型  函数名(参数表){

    }
void：没有返回值
函数调用： 函数名(实参);
参数表： 提高函数的可重用性;灵活性
返回值类型： 获取函数中有用的结果
作用：     
            减少冗余代码
            提高代码的可重用性
            参数）提高代码灵活性
    public static String doEdit(String a) { 

        String strResult = a.substring(0,4);    

        return strResult;
    }   
###  方法调用
    1   LingXingDiaoYong.downStr();     //直接LingXingDiaoYong里的方法down.Str

    2   LingXingDiaoYong graph = new LingXingDiaoYong();
        graph.upStr();                  //间接调用

---

十、构建随机数

    //如何设置随机数
    Random random = new Random();
    //令随机数最大值为99
    int ran = random.nextInt(100);

---

十一、构建方程

    public static void main(String[] args){
        for(int x = 0; x < 100;x++){
            for(int y = 0;y < 1000;y++){
                for(int z = 0;z < 100;z++){
                    boolean bln = xAddy(x,y,z,18);
                    boolean bln2 = xAddy(8*x, 6*y,6*z, 118);
                    boolean bln3 = xAddy(0,2*y,z,20);

                if(bln&&bln2&&bln3){        
                    System.out.println(x);
                    System.out.println(y);
                    System.out.println(z);
                }
                }
            }
        }
    }

    public static boolean xAddy (int x, int y ,int z ,int k){
        boolean bln =(x + y + z == k);
        return bln;
    }

---

十二、数组

能存储多个同类型数据的变量
特点：空间是连续的，变量中存储的是数组的地址

### 定义数组：
        ①   //定义一个整型数组变量a
            int[]  a; 
            //给a数组赋值:int 
            a = new int[]{1,2,3,4,5};
        ②：
            //定义一个数组，分配5个空间(意味着a数组中可以存5个int类型的值)
            int[] a = new int[5];
            a[0] = 1;
            a[1] = 2;
            a[2] = 3;
            a[3] = 4;
            a[4] = 5;
            a[5] = 6;
            a[5] = 6;//不能：ArrayIndexOutOfBoundsException
                        //数组下标越界：
            a[-1] = 10;//不能
                *******************************
                    简单类型变量，存值
                    对象类型（复杂类型），存地址
                ******************************
        ③：
            //定义一个数组，赋值10，20,30,40，50
            int[] a = {10,20,30,40,50};
    **a.leng**
        数组的长度
    数组的遍历
        //根据下标遍历数组
            for(int i=0;i<a.length;i++){
                    System.out.println(a[i]);
                }
    【重点】：数组本身长度是不能改变的

### 数组扩容 
        public class Test4_2{
            public static void main(String[] args){
                    int[] a = {1,2,3,4,5};
                    a = expand(a);
                    print(a);
                }
            public static int[] expand(int[] b){
                    int[] newArray  = new int[b.length*2];
                    System.arraycopy(b,0,newArray,0,b.length);
                    return newArray;
                }
        }

### 挑出100以内的所有素数，并截取掉了后面所有的0（截0的方法很不想）
    public static int[] meth(int j) {

        int[] x = new int[j];
        int k = 0;
        for (int i = 2; i < j; i++) {
            if (method(i)) {
                x[k] = i;
                k++;  
            }
        }
        int[] y=new int[k];
        int n=0;
        for(int m:x){
            if(m!=0){
                y[n]=m;
                n++;    
            }
        }
        return y;
    }

### sort排序

    public class SortArray {
        public static void main(String[] args){
            int[] arr = {10,50,20,1,80,75};
            int temp = 0;
            int i = 0;
            for(i = 0; i < arr.length;i++){
                for(int j = arr.length - 1; j > i ;j--){
                    if(arr[i] > arr[j]){
                        temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp;
                    }

                }
                System.out.println(arr[i]);
            }


        }
    }

### 另一种排序方式

---

十三、Collection接口

### List （size、isEmpty、get、set、iterator 和 listIterator）

ArrayList
此类大致上等同于 Vector 类，除了此类是不同步的。

    List<String> list = new ArrayList<String>();
    // 把变量加到collection中
    list.add(strA);
    list.add(strB);
    // 移除指定位置的元素
    list.remove(0);
    // 把strA给到第一个格里面
    list.set(0,strA);
    // isEmpty判断是否为空    
    System.out.println(list.isEmpty());
    // list有几个格
    System.out.println(list.size());
    // list提取出第二个格里面的变量（obj）转为String型
    System.out.println((String)list.get(1));    
    // 对象类型的list，不设置类型
    List list2 = new ArrayList();
    list2.add("1");
    list2.add(BigDecimal.TEN);
    list2.add("3");
    //按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
    Object[] obj = list.toArray();

    //判定输出是String
    if(obj[0] instanceof String){
        System.out.println(obj);
    }
    //清除全部
    list.clear();

    //插入到index位置上，index以及后面的位置都顺延一位
    add(index,对象)

### Map

HashMap
基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

    Map类的方法表
         void   clear() 
                  从此映射中移除所有映射关系。
         Object clone() 
                  返回此 HashMap 实例的浅表副本：并不复制键和值本身。
         boolean containsKey(Object key) 
                  如果此映射包含对于指定键的映射关系，则返回 true。
         boolean    containsValue(Object value) 
                  如果此映射将一个或多个键映射到指定值，则返回 true。
         Set<Map.Entry<K,V>>    entrySet() 
                  返回此映射所包含的映射关系的 Set 视图。
         V  get(Object key) 
                  返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
         boolean    isEmpty() 
                  如果此映射不包含键-值映射关系，则返回 true。
         Set<K> keySet() 
                  返回此映射中所包含的键的 Set 视图。
         V  put(K key, V value) 
                  在此映射中关联指定值与指定键。
         void   putAll(Map<? extends K,? extends V> m) 
                  将指定映射的所有映射关系复制到此映射中，这些映射关系将替换此映射目前针对指定映射中所有键的所有映射关系。
         V  remove(Object key) 
                  从此映射中移除指定键的映射关系（如果存在）。
         int    size() 
                  返回此映射中的键-值映射关系数。
         Collection<V>  values() 
                  返回此映射所包含的值的 Collection 视图。

    public static void main(String[] args) {
        //类似List
        Map<String,String> map = new HashMap<String,String>();
        map.put("key","1");
        map.put("key2","9");

        //取出所在key的value值
        String rtnValue = (String)map.get("key");
        System.out.println(rtnValue);
        System.out.println(map.size());

        //把所有的key都循环的输出（不是顺序输出）
        Set<String> set = map.keySet();
        System.out.println(set);
        //分别输出所有的key
        for(String dataKey : map.keySet())     
        System.out.print(dataKey+"\t" );                


        //移除要求的key值
        map.remove("key");      
        System.out.println(set);

        //清除所有结果
        map.clear();
        System.out.println(set);

    }

    keyset的问题
        有一个Map对象，这时候使用keySet()方法获取所有的key值，比如：
           Map map = new HashMap();
           map.put(1, "a");
           map.put(2, "b");
           map.put(3, "c");
           map.put(4, "d");
           Set keys1 = map.keySet();
           Set keys2 = map.keySet();
           Set keys3 = map.keySet();
    上面三个set对象key1，key2，key3引用的是一个对象。这时map的keySet()方法只返回一个set实例，所以当从key1中删除一个对象时候，key2和key3将会受到影响。
       keys1.remove(1);
       System.out.println(keys1);
       System.out.println(keys2);
       System.out.println(keys3);
    打印结果为：
    [2, 4, 3]
    [2, 4, 3]
    [2, 4, 3]

---

接口的定义与实现

### 接口的定义
    接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下：
        [修饰符] interface 接口名 [extends 父接口名列表]{
        [public] [static] [final] 常量;
        [public] [abstract] 方法;
        }
    修饰符：可选，用于指定接口的访问权限，可选值为public。如果省略则使用默认的访问权限。
    接口名：必选参数，用于指定接口的名称，接口名必须是合法的Java标识符。一般情况下，要求首字母大写。
    extends 父接口名列表：可选参数，用于指定要定义的接口继承于哪个父接口。当使用extends关键字时，父接口名为必选参数。
    方法：接口中的方法只有定义而没有被实现。    
    例子：
        public interface CalInterface   
        {  
            final float PI=3.14159f;//定义用于表示圆周率的常量PI  
            float getArea(float r);//定义一个用于计算面积的方法getArea()  
            float getCircumference(float r);//定义一个用于计算周长的方法getCircumference()  
        }  
    注意：与Java的类文件一样，接口文件的文件名必须与接口名相同。

### 接口的实现   
    接口在定义后，就可以在类中实现该接口。在类中实现接口可以使用关键字implements，其基本格式如下：
        [修饰符] class <类名> [extends 父类名] [implements 接口列表]{
        }
    修饰符：可选参数，用于指定类的访问权限，可选值为public、abstract和final。
    类名：必选参数，用于指定类的名称，类名必须是合法的Java标识符。一般情况下，要求首字母大写。
    extends 父类名：可选参数，用于指定要定义的类继承于哪个父类。当使用extends关键字时，父类名为必选参数。
    implements 接口列表：可选参数，用于指定该类实现的是哪些接口。当使用implements关键字时，接口列表为必选参数。当接口列表中存在多个接口名时，各个接口名之间使用逗号分隔。

    在类中实现接口时，方法的名字、返回值类型、参数的个数及类型必须与接口中的完全一致，并且必须实现接口中的所有方法。例如，编写一个名称为Cire的类，该类实现5.7.1节中定义的接口Calculate，具体代码如下：      
        public class Cire implements CalInterface   
        {  
            public float getArea(float r)   
            {  
                float area=PI*r*r;//计算圆面积并赋值给变量area  
                return area;//返回计算后的圆面积  
            }  
            public float getCircumference(float r)   
            {  
                float circumference=2*PI*r;      //计算圆周长并赋值给变量circumference  
                return circumference;           //返回计算后的圆周长  
            }  
            public static void main(String[] args)   
            {  
                Cire c = new Cire();  
                float f = c.getArea(2.0f);  
                System.out.println(Float.toString(f));  
            }  
        }  

    在类的继承中，只能做单重继承，而实现接口时，一次则可以实现多个接口，每个接口间使用逗号“,”分隔。

---

split

split
根据匹配给定的正则表达式来拆分此字符串。

用类似 . 分割符需要加\\（如    .   |    \   分割时改为   \\.   \|    \\)
如果在一个字符串中有多个分隔符，可以用“|”作为连字符，比如：“a=1 and b =2 or c=3”,把三个都分隔出来，可以用String.split("and|or");

    String str ="19.34|56.78|88";       
    String[] str1 = str.split("\\.");
    for(String m:str1){
        System.out.println(m);
    }

    String[] str2 = str.split("\|");
    for(String n:str2){
        System.out.println(n);
    }       }