JAVA总结

来源：互联网发布：python http接口编辑：程序博客网时间：2024/06/10 04:10

Java

Java
- Java简介
- Java基础
  - 1 Hello World起步程序
  - 2 Java关键字
  - 3 Java注释
  - 4 Java基本数据类型
  - 5 Java 常量全局变量局部变量类变量静态变量实例变量
  - 6 Java访问修饰符
  - 7 Java访问运算符
  - 8 Java循环结构
- Java字符串处理
  - 1获取字符串长度
  - 2获取字符串对应大小写字符串
  - 3获取字符串中指定索引字符字符索引
  - 4比较字符串是否相等是否相同
  - 5字符串进行裁剪连接替换
  - 6对字符串进行前缀以及后缀判断
  - 7对字符串转换数字字节数组字符串数组
- Java数组
  - 1 一维数组
  - 2 二维数组
- Java流操作 IO输入输出操作 File文件流操作
  - 1 IO输入输出流
  - 1 File文件输入输出流

1.Java简介

创始人: James Gosling 詹姆斯•高斯林
创始年份: 1991创建(Oak) 1994改名(Java)
曾用名: Oak
特性: 跨平台的面向对象高级编程语言
运行方式:虚拟机运行编译生成的Java字节码
口号: Compile once，run everywhere
用途: Web网页应用程序分布式系统桌面应用安卓APP
发展: 即将在2017年9月份推出Java 9,现属于Oracle公司知识产权
IDE集成开发环境: Eclipse JDK配置
开源包框架

2.Java基础

2.1 Hello World起步程序

A.java

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

使用Eclipse直接运行: 输出: Hello World
使用Java命令编译运行: $ javac A.java [生成A.class]; $ java A [运行A.class文件]; 输出: Hello World

2.2 Java关键字

关键描述 abstract 抽象方法，抽象类的修饰符 assert 断言条件是否满足 boolean 布尔数据类型 break 跳出循环或者label代码段 byte 8-bit 有符号数据类型 case switch 语句的一个条件 catch 和try搭配捕捉异常信息 char 16-bit Unicode字符数据类型 class 定义类 const 未使用 continue 不执行循环体剩余部分 default switch语句中的默认分支 do 循环语句，循环体至少会执行一次 double 64-bit双精度浮点数 else if条件不成立时执行的分支 enum 枚举类型 extends 表示一个类是另一个类的子类 final 表示一个值在初始化之后就不能再改变了表示方法不能被重写，或者一个类不能有子类 finally 为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。 float 32-bit单精度浮点数 for for循环语句 goto 未使用 if 条件语句 implements 表示一个类实现了接口 import 导入类 instanceof 测试一个对象是否是某个类的实例 int 32位整型数 interface 接口，一种抽象的类型，仅有方法和常量的定义 long 64位整型数 native 表示方法用非java代码实现 new 分配新的类实例 package 一系列相关类组成一个包 private 表示私有字段，或者方法等，只能从类内部访问 protected 表示字段只能通过类或者其子类访问子类或者在同一个包内的其他类 public 表示共有属性或者方法 return 方法返回值 short 16位数字 static 表示在类级别定义，所有实例共享的 strictfp 浮点数比较使用严格的规则 super 表示基类 switch 选择语句 synchronized 表示同一时间只能由一个线程访问的代码块 this 表示调用当前实例或者调用另一个构造函数 throw 抛出异常 throws 定义方法可能抛出的异常 transient 修饰不要序列化的字段 try 表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码 void 标记方法不返回任何值 volatile 标记字段可能会被多个线程同时访问，而不做同步 while while循环

2.3 Java注释

public class A{   /* 这是第一个Java程序    *它将打印Hello World    * 这是一个多行注释的示例    */    public static void main(String []args){       // 这是单行注释的示例       /* 这个也是单行注释的示例 */       System.out.println("Hello World");     }}

2.4 Java基本数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
1.byte：
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。
2.short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。
3.int：
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。
4.long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
“L”理论上不分大小写，但是若写成”l”容易与数字”1”混淆，不容易分辩。所以最好大写。
5.float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
6.double：
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。
7.boolean：
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。
8.char：
char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = ‘A’;。

2.5 Java 常量全局变量局部变量类变量<静态变量> 实例变量

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;

类变量（静态static变量）：独立于方法之外的属于类的共同的变量，用 static 修饰
实例变量: 依据类创建的具体的个人对象都标配的成员变量
局部变量: 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁。
全局变量: Java程序中，不能在所有类之外定义全局变量，只能通过在一个类中定义公用、静态的变量来实现一个全局变量

public class A{    static int allClicks=0;    // 类变量<全局变量>    A a ; // 实例变量<实例变量>    String str="hello world";  // 实例变量    public void method(){        int i =0;  // 局部变量    }}

2.6 Java访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
public 共有的，以 public 修饰符指定，对所有类可见。
protected 受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。
default默认的，也称为 default，在同一包内可见，不使用任何修饰符。
private 私有的，以 private 修饰符指定，在同一类内可见。

JAVA访问修饰符作用范围

2.7 Java访问运算符

【<<】左移位运算符和【>>】右移位运算符

public class A {public static void main(String[] args) {int a =1; //  a<<1 表示  0000 0001 左移1位  ==  0000 0010 【值为 2】System.out.println("a:"+ (a<<1));int b =2; //  b<<2 表示  0000 0010 左移1位  ==  0000 1000 【值为 8】System.out.println("b:"+ (b<<2));int c =3; //  c<<3 表示  0000 0011 左移3位  ==  0001 1000 【值为 24】System.out.println("c:"+ (c<<3));int d =4; //  d>>1 表示  0000 0100 右移1位  ==  0000 0010 【值为 2】System.out.println("d:"+ (d>>1));int e =5; //  e>>2 表示  0000 0101 右移2位  ==  0000 0001 【值为 1】System.out.println("b:"+ (e>>2));int f =6; //  f>>3 表示  0000 0110 右移3位  ==  0000 0000 【值为 0】System.out.println("c:"+ (f>>3));}}

输出:
a:2
b:8
c:24
d:2
b:1
c:0

++自增和 – 自减运算符
A++ ：先赋值最后才进行自身+1
++A ：先进行自身+1最后才赋值打印
B- - : 先赋值最后才进行自身-1
–B : 先进行自身-1最后才赋值

public class B {public static void main(String[] args) {int a =10;System.out.println("a = "+ ++a);int b =10;System.out.println("b = "+ b++);int c =5;System.out.println("c = "+ --c);int d =5;System.out.println("c = "+ d--);}}

输出:
a = 11
b = 10
c = 4
c = 5

instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

public class B {public static void main(String[] args) {    String name = "James";    boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真    if(name instanceof String){        System.out.println("name is String type");    }    else{        System.out.println("name is not  String type");    }}}

输出: name is String type

2.8 Java循环结构

for 循环

普通for循环

public class Test {public static void main(String args[]) {    for(int i=1;i<=9;i++){        for(int j=1;j<=i;j++){            System.out.print(j+"*"+i+"="+i*j+" ");        }        System.out.println();    }}}

增强型for循环

public class A {public static void main(String args[]){  int [] numbers = {10, 20, 30, 40, 50};  for(int x : numbers ){//增强for循环     System.out.print( x );     System.out.print(",");  }  System.out.print("\n");  String [] names ={"James", "Larry", "Tom", "Lacy"};  for( String name : names ) { //增强for循环     System.out.print( name );     System.out.print(",");  }}}

for语句流程图

这里写图片描述

while 循环

public class A {public static void main(String args[]) {  int x = 10;  while( x < 20 ) {     System.out.print("value of x : " + x );     x++;     System.out.print("\n");  }}}

do…while 循环

public class A {public static void main(String args[]){  int x = 10;  do{     System.out.print("value of x : " + x );     x++;     System.out.print("\n");  }while( x < 20 );}}

循环结构与break，continue关系

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

public class A {public static void main(String args[]) {  int [] numbers = {10, 20, 30, 40, 50};  for(int x : numbers ) {     // x 等于 30 时跳出循环     if( x == 30 ) {        break;   // 跳出For循环     }     System.out.print( x );     System.out.print("\n");  }}}输出结果: 1020

public class A {public static void main(String args[]) {  int [] numbers = {10, 20, 30, 40, 50};  for(int x : numbers ) {     if( x == 30 ) {    continue;  // 继续for循环下一个迭代     }     System.out.print( x );     System.out.print("\n");  }}}输出结果: 10204050

3.Java字符串处理

3.1获取字符串长度

获取字符串中包含的字符数： length()

public class A {public static void main(String[] args) {    String str = "abcdef";    System.out.println(str.length()); //输出字符串长度为5}}

自动去掉字符串的前空白，尾空白 trim()

public class A {public static void main(String[] args) {    String str = " abcdef ";    System.out.println(str.length());  //输出字符串长度原长度为7    System.out.println(str.trim().length()); //输出去空白字符串长度为5}}

3.2获取字符串对应大小写字符串

public class A {public static void main(String[] args) {    String str = "aBcDeF";    System.out.println(str.toLowerCase()); //输出小写字符串 abcdef    System.out.println(str.toUpperCase()); //输出大写字符串 ABEDEF}}

3.3获取字符串中指定索引字符，字符索引

获取指定索引字符charAt(int index)

public class A {public static void main(String[] args) {    String str = "aBcDeF";    System.out.println(str.charAt(0)); //输出字符 a    System.out.println(str.charAt(1)); //输出字符 B    System.out.println(str.charAt(2)); //输出字符 c}}

获取指定字符在此字符串中第一次出现处的索引 indexOf(char c) indexOf(String str)

public class A {public static void main(String[] args) {    String str = "aBcDeF";    System.out.println(str.indexOf('B')); //输出index字符索引 1    System.out.println(str.indexOf('D')); //输出index字符索引 3    System.out.println(str.indexOf("eF")); //输出index字符串索引 4}}

获取指定字符在此字符串中最后一次出现处的索引

public class A {public static void main(String[] args) {    String str = "ABCDDCBA";    System.out.println(str.lastIndexOf('B')); //输出最后index字符'B'的索引 6    System.out.println(str.lastIndexOf("CBA")); //输出最后index字符“CBA”的索引 5}}

3.4比较字符串是否相等是否相同

==(是否同一个内存对象) 和 eauql(字符字面量是否相同)
compareTo(String str) compareToIgnoreCase(String str) 判断字面量

public class A {    public static void main(String args[]) {        String str1 = "Strings";        String str2 = "Strings";        String str3 = "Strings123";        String str4 = new String("Strings");        int result = str1.compareTo( str2 );         System.out.println(result);// 输出为0: 如果参数字符串等于此字符串，则返回值 0        result = str2.compareTo( str3 );        System.out.println(result);// 输出为-3 : 如果此字符串小于字符串参数，则返回一个小于 0 的值        result = str3.compareTo( str1 );        System.out.println(result);// 输出为3 : 如果此字符串大于字符串参数，则返回一个大于 0 的值        if(str1.equals(str2)){            System.out.println("str1 str2 这两个字符串字面相等"); //输出 str1 str2 这两个字符串字面相等        }        else {            System.out.println("str1 str2 这两个字符串字面不相等");            }        if(str1 == str2){            System.out.println("str1 str2 这两个字符串是同一个对象");//输出str1 str2 这两个字符串是同一个对象        }        else {            System.out.println("str1 str2 这两个字符串不是同一个对象");          }        if(str1.equals(str4)){            System.out.println("str1 str4 这两个字符串字面相等"); //输出str1 str4 这两个字符串字面相等        }        else {            System.out.println("str1 str4 这两个字符串字面不相等");            }        if(str1 == str4){            System.out.println("str1 str4 这两个字符串是同一个对象");        }        else {            System.out.println("str1 str4 这两个字符串不是同一个对象");//输出 str1 str4 这两个字符串不是同一个对象        }    }}

3.5字符串进行裁剪，连接，替换

concat()方法进行字符串的连接
substring(int index) 进行截取字符串
replace(char a,char b) replace(str a,str b) 进行字符串替换

public class A {    public static void main(String args[]) {        String s = "Hello ";        System.out.println(s+"World!"); // 输出  Hello World!        s = s.concat("World!");        System.out.println(s); // 输出  Hello World!        System.out.println(s.replace('o', 'X')); // 输出  HellX WXrld!        System.out.println(s.replace("ll", "LL"));// 输出 HeLLo World!        System.out.println(s.substring(4));// 输出  o World!        System.out.println(s.substring(0,4));// 输出  Hell    }}

3.6对字符串进行前缀以及后缀判断

boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始

public class A {    public static void main(String args[]) {        String s = "Hello World";        System.out.println(s.startsWith("He"));// 输出 true        System.out.println(s.startsWith("he"));// 输出 false        System.out.println(s.endsWith("ld")); // 输出 true        System.out.println(s.endsWith("LD"));// 输出 false    }}

3.7对字符串转换，数字，字节数组，字符串数组…

全数字型字符串转为数字

public class A {    public static void main(String args[]) {        String s = "123456789";        int value = (int) Integer.valueOf(s);        System.out.println(value - 9); // 字符串转为int整型再进行加减 输出: 123456780    }}

字符串转为字节数组，字节数组转为字符串
byte[] getBytes() byte[] getBytes(String charsetName) 转为字节数组
static String copyValueOf(char[] data) new String(byte[] arr)字节数组转为字符串

import java.io.UnsupportedEncodingException;public class A {    public static void main(String args[]) {        String s = "ABCDEF";        try {            byte[] arr = s.getBytes("UTF-8"); // 字符串转为字节数组            System.out.println(arr[0]);// 输出第一个字节A对应的ASCII码  65            System.out.println(arr[1]);// 输出第一个字节A对应的ASCII码  66            System.out.println(arr[2]);// 输出第一个字节A对应的ASCII码  67            System.out.println(arr[3]);// 输出第一个字节A对应的ASCII码  68            System.out.println(arr[4]);// 输出第一个字节A对应的ASCII码  69            System.out.println(arr[5]);// 输出第一个字节A对应的ASCII码  70            System.out.println((char) arr[0]);// 输出第一个字节arr[1]对应的ASCII码  65 转为字符为 A            System.out.println((char) arr[1]);// 输出第一个字节arr[1]对应的ASCII码  66 转为字符为 B            System.out.println((char) arr[2]);// 输出第一个字节arr[1]对应的ASCII码  67 转为字符为 C            System.out.println((char) arr[3]);// 输出第一个字节arr[1]对应的ASCII码  68 转为字符为 D            System.out.println((char) arr[4]);// 输出第一个字节arr[1]对应的ASCII码  69 转为字符为 E            System.out.println((char) arr[5]);// 输出第一个字节arr[1]对应的ASCII码  70 转为字符为 F        } catch (UnsupportedEncodingException e) {            e.printStackTrace();        }        byte[] arr2={(byte) 0xFF,(byte)0xAA,(byte)0x7A,(byte)0x6A,(byte)0x55};        String str2 = new String(arr2);        System.out.println(str2); // 打印 ��zjU    }}

4.Java数组

4.1 一维数组

首先必须声明数组变量，才能在程序中使用数组
dataType[] arrayRefVar ; int[] intArr; String[] strArr;
int size = 10;
double[] listDouble = new double[size];
int[] intArr = new int[size]; //数组初始化方式一
int[] intArr2 = {4,5,3,2,7,8,90,7,5,325,342} //数组初始化方式二

public class A {    public static void main(String[] args) {        double[] myList = { 1.9, 9.9, 3.4, 3.5 }; // 创建方式一: 每一位都赋予初始值        // 打印所有数组元素        for (int i = 0; i < myList.length; i++) {            System.out.println(myList[i] + " ");        }        // 计算所有元素的总和        double total = 0;        for (int i = 0; i < myList.length; i++) {            total += myList[i];        }        System.out.println("Total is " + total);        // 查找最大元素        double max = myList[0];        for (int i = 1; i < myList.length; i++) {            if (myList[i] > max)                max = myList[i];        }        System.out.println("Max is " + max);        int size = 4;        int[] myList1 = new int[size]; // 创建方式二: 所有Item默认为0.0        for (int i = 0; i < myList1.length; i++) {            myList1[i] = i; // 数组赋值            System.out.println("value" + i + " " + myList1[i]);        }    }}

4.2 二维数组

二维数组 a可以看成有行有列的表
String s[][] = new String[2][]
String str[][] ={{“Hello”,”Hello”},{“Today”,”freestyle”}}

import java.util.Arrays;public class A {    public static void main(String[] args) {        String s[][] = new String[2][];//二维数组  其中一维数组长度可以不确定        s[0] = new String[2];  // 一维数组        s[1] = new String[3];        s[0][0] = new String("Good");        s[0][1] = new String("Luck");        s[1][0] = new String("to");        s[1][1] = new String("you");        s[1][2] = new String("!");        System.out.println(Arrays.toString(s[0])); //输出 [Good, Luck]        System.out.println(Arrays.toString(s[1]));//输出 [to, you, !]        String str[][] ={{"Hello","Hello"},{"Today","freestyle"}};        System.out.println(Arrays.toString(str[0])); //输出 [Hello, Hello]        System.out.println(Arrays.toString(str[1]));//输出 [Today, freestyle] }}

5.Java流操作 IO输入输出操作 File文件流操作

5.1 IO输入输出流

输入流表示从一个源读取数据，输出流表示向一个目标写数据
Java 的控制台输入由 System.in 完成
可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
通过new BufferedReader(new InputStreamReader(System.in)).read()读取控制台字符

// 使用 BufferedReader 在控制台读取字符  若输入字符包含q则停止import java.io.*;public class A {  public static void main(String args[]) throws IOException  {    char c;    // 使用 System.in 创建 BufferedReader     BufferedReader br = new BufferedReader(new                        InputStreamReader(System.in));    System.out.println("输入字符, 按下 'q' 键退出。");    // 读取字符    do {       c = (char) br.read();       System.out.println(c);    } while(c != 'q');  }}

通过new BufferedReader(new InputStreamReader(System.in)).readLine() 读取控制台字符串字符集

// 使用 BufferedReader.readLine() 在控制台读取字符串  若输入字符串end则停止import java.io.*;public class A {  public static void main(String args[]) throws IOException  {    // 使用 System.in 创建 BufferedReader     BufferedReader br = new BufferedReader(new                            InputStreamReader(System.in));    String str;    System.out.println("Enter lines of text.");    System.out.println("Enter 'end' to quit.");    do {       str = br.readLine();  //读取字符串       System.out.println(str);       System.out.println();    } while(!str.equals("end"));  }}

5.1 File文件输入输出流