javaee学习日记之java基础之初识java

准备工作
jdk下载安装
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
（官网下载）
安装分两步（第一步安装jdk,第二步安装jre（最好安装在全英文目录下））
jdk: java工具包
jre: java运行环境
jvm: java虚拟机

配置环境变量：
系统变量→新建 JAVA_HOME 变量
在Path后加 ; %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
新建 CLASSPATH 变量
变量值填写 .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
进入cmd
输入 java 如果显示一堆中文+英文
再输入javac 如果显示一堆中文+英文
上述两者均满足则配置成功，不然就失败了。

第一个程序代码：

class Hello{
     public static void main(String[] args){
         System.out.println("Hello");
     }
}

在自己新建的一个英文目录下新建一个Hello.java文件用记事本打开在里面编写；
（注意java是强类型语言，区分大小写）
在根目录下按住shift键鼠标右键点击，打开cmd窗口
输入javac Hello.java(如果没有显示任何东西，表示编译成功)
再输入java Hello(显示Hello,第一个程序成功！)

标识符：（变量名，类名（首字母大写））
由字母，数字，下划线，美元符号组成，第一个不能是数字，
不能是关键字和保留字；
关键词：
（八大基本数据类型）
byte(基本数据类型 整型(1字节(一个字节8位)))
int(基本数据类型 整型(4字节))(默认)
short(基本数据类型 整型(2字节))
long(基本数据类型 长整型(8字节))
char(基本数据类型 字符型(2字节))
float(基本数据类型 单精度浮点数(4字节))
double(基本数据类型 双精度浮点数(8字节))(默认)
boolean(基本数据类型 布尔类型())

(基本语句关键词)
if(条件语句)
else(条件不成立)
do(循环前执行一次)
while (循环）
for(循环)
switch(条件分支语句)
case(分支语句 )
break(跳出当前一层循环)
default(条件分支结束)
continue(跳出一次循环)
return(返回)

(异常关键词)
try(异常捕获)
catch( 异常处理)
finally(在异常发生后仍执行)
throw(抛异常)
throws(声明异常)

(访问控制符)
public(类内部true，本包true，子类true，外部包true)
protected(类内部true，本包true，子类true，外部包false)
default(类内部true，本包true，子类false，外部包false)
private(类内部true，本包false，子类false，外部包false)

(类修饰符)
extends(继承)
abstract(可以修饰类和方法，抽象)
enum(枚举)
final(不可修改)
class( 类)
implements(实现)
interface(接口)
import(导包)
new(创建新对象)
super(调用父类方法或属性)
this(本对象)
static(静态修饰符)
void(没有返回值)
synchronized(同步)
package(包)

(不常用关键词)
assert(断言)
instanceof( 运算符是用来在运行时指出对象是否是特定类的一个实例)
native(调用其它语言)
strictfp(精确浮点)
transient(阻止实例中那些用此关键字声明的变量序列化(即反序列化后读取不到)),
volatile(每次访问从主内存中重读),

保留字
byValue, cast, false(不成立), future, generic, inner,
outer, rest, true(成立), var , goto(c语言中是跳出多层循环(但也不推荐使用))，const,null(空),operator,

基本数据类型转换
范围大小：
byte = char < short=char < int(默认类型) < long < float < double(默认类型)
当类型范围小的向大的转换（不需要强制转换(如果低级类型为char型，向高级类型（整型）转换时，会转换为对应Unicode码值,如果转换成浮点数的话，Unicode码值.0)）
当类型范围大的向小的转换（需要强制转换）（同级也需要强制转换）

基本数据类型运算
算数运算符：

+(加)
-(减)
*(乘)
/(除)
%(整除)
++(自加)
--(自减)

关系运算符

==(等于)
!=(不等于)
>(大于)
<(小于)
>=(大于等于)
<=(小于等于)

逻辑运算符

&&(短路与(当第一个不满足就不执行))
||(短路或(当第一个满足就执行))
!(非)
^(异或)
&(按位与)
|(按位或)

位运算符

!(非)
^(异或)
&(按位与)
|(按位或)
>>(左移)
<<(右移)
>>>(无符号左移)

赋值运算符

=(赋值)

运算符优先级(算数运算符>关系运算符>逻辑运算符>赋值运算符)
三目运算符

int x = 10;
int y = 10;
int max = (x > y)?x:y;

基本数据类型对应的包装类型
short Short 2个字节
int Integer 4个字节
long Long 8个字节
float Float 4个字节
double Double 8个字节
byte Byte 1个字节
char Character 2个字节
boolean Boolean

数组(数组初始化(必须给定长度或给定元素))(是引用对象)

 int[] arr = {1,2,3};//推荐使用
 int arr[] = {1,2,3};
 int[] arr = new int[10];
 int arr[] = new int[10];
 int[] arr = new int[]{1,2,3};

操作数组的类(Array,Arrays);

数组排序
冒泡排序

int[] arr = {464,464,131,649,399,6,46,1369};
for(int x = 0;x < arr.length-1;x++){
    for(int y = x + 1;y < arr.length;y++){
        int w = 0;
        if(arr[x] > arr[y]){
            w = arr[x];
            arr[x] = arr[y];
            arr[y] = w;
        }
    }
}

选择排序

   int[] arg = {464,464,131,649,399,6,46,1369};
         for (int x = 0;x < arg.length - 1 ;x++ ){   
                int w = x;   
                for (int j = i+1 ;j < arg.length ;j++ ){   
                      if (arg[w]>args[j]){   
                           w = j;   
                           }   
                  }   
                      if (w != i){  
                      int temp = arg[i];  
                      arg[i] = arg[w];  
                      arg[w] = temp;          
                  }  
            }  

插入排序

int[] tab = {464,464,131,649,399,6,46,1369};
for(int x = 1;x < tab.length;x++){
    for(int y = x;y > 0;y--){
        if(tab[y] < tab[y-1]){
            int te = tab[y-1];
            tab[y-1] = tab[y];
            tab[y] = te;
        }else break;
    }
 }

快速排序(要导包)

int[] tab = {464,464,131,649,399,6,46,1369};
        Arrays.sort(tab);
       for(int y = 0;y < tab.length;y++){
           System.out.println(tab[y]);
       }

上述数组均为一维数组，二维数组如下

int[][] arr = {{11,15,25},{46,794,66},{464,454,48}};
//数组可以看作表格来处理

数组维度可以一直创建下去但实用性不高。

字符串对象

字符串连接

String s1 = new String("Hello");
String s2 = new String("World");
String s = s1 + s2;
String s3 = "Hello";
String s4 = "World";
String s5 = s3 + s4;
//但s5 != s 而 s5.equals(s6)：返回true
//关于equals方法（比较String的对象的内容()）(虽然是继承于Object类的方法，但进行了重写)
//而==比较的是栈内存中存的东西是否相同(基本数据类型变量直接在栈中储存值，而引用类型储存在栈中的是堆中的内存地址)
//在Object类的equals()方法（底层用的也是==）
//关于equalsIgnoreCase():(忽略大小写进行内容对比)
String ss = "helloworld";
s.equalsIgnoreCase(ss);
//
String str = "ABC";
System.out.println(str.toLowerCase());
String stc = str.toLowerCase();
System.out.println(stc.toUpperCase());
//toLowerCase():将字符串全部转换小写
//toUpperCase():将字符串全部转换大写
//
         String s = "464bgsags41236";
         System.out.println(s.startsWith("4"));
         System.out.println(s.endsWith("6"));
//startsWith():判断字符串是否以指定字符串开头
//endsWith():判断字符串是否以指定字符串结尾
//
         String s = "b5g4s0a5g3s";
         String[] tab = s.split("\\d");
         for(int i = 0;i < tab.length;i++){
             System.out.println(tab[i]);
         }
//split():以指定字符串或正则表达式分割字符串转换成字符串数组
//
         String s = "b5g4s0a5g3s";
         String[] tab = s.split("\\d",2);
         for(int i = 0;i < tab.length;i++){
             System.out.println(tab[i]);
         }
//split()以指定字符串或正则表达式分割字符串转换成字符串数组
,指定数组长度

正则表达式

\d       表示数字
\w       表示
^        开头
$        结尾
|        或(不能加空格)
+        表示1个或多个
?        非(不能加空格)      
&        与(不能加空格)
\W       表示
\S       表示非空格
\s       表示空格
\D       表示非数字
[0-9]    表示数字
[a-Z]    表示大小写字母
[a-z]    表示小写字母
{1,5}    最小长度1，最大长度5
{10}     长度为10
.        表示任何字符
*        表示0个或多个
或是Unicode编码

//使用
 Pattern p = Pattern.compile("\^a\\wb$");//(注意要加转义符'\')
 Matcher m = p.matcher("aaaaab");
 boolean b = m.matches();
 //当字符串与正则表达式匹配b就为true

String(不可变(每次操作都要开辟新的内存空间))
StringBuffer:(字符串缓存区) (节约内存)
StringBuilder:(字符串缓存区(线程不安全（效率比StringBuffer高）))

public class Test {
    public static void main(String[] args) {
        String str = "";
        long starTime = System.currentTimeMillis();
        for(long i = 0;i < 30000;i++){
            str = str + i;
        }
        long endTime = System.currentTimeMillis();
        long time = endTime - starTime;
        System.out.println("String消耗时间：" + time);

        StringBuilder sbr = new StringBuilder("");
        starTime = System.currentTimeMillis();
        for(long i = 0;i < 10000000;i++){
            sbr.append(i);
        }
        endTime = System.currentTimeMillis();
        time = endTime - starTime;
        System.out.println("StringBuilder消耗时间:" + time);

        StringBuffer sb = new StringBuffer("");
        starTime = System.currentTimeMillis();
        for(long i = 0;i < 10000000;i++){
            sb.append(i);
        }
        endTime = System.currentTimeMillis();
        time = endTime - starTime;
        System.out.println("StringBuffer消耗时间:" + time);
    }
}