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);
    }
}
展开阅读全文

没有更多推荐了,返回首页