java基础语法
对象/类/方法/实例/继承
-
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色，名字，品种；行为有：摇尾巴，叫，吃等。
-
类：类是一个模版，它描述一类对象的行为和状态
-
方法：方法就是行为，一个类可以有很多方法。逻辑运算，数据修改以及所有动作都是在方法中完成的
-
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定
-
继承：在java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性和方法，那么你可以将新创建的类继承该类。利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（sub class）。
注：java类名命名规范：大驼峰，方法名命名规范：小驼峰。
Java修饰符：
-
访问控制修饰符：default,public,protected,private
-
非访问控制修饰符：final，abstract，static，synchronized
Java变量
-
局部变量：在方法，构造方法或者语句块中定义的变量称为局部变量。变量声明和初始化都在方法中，方法结束后，变量就会自动销毁。
-
类变量：类变量页声明在类中，方法体之外，但必须声明为static类型
-
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中的方法，构造方法和特定类的语句块访问。
一个类可以拥有多种方法。
java枚举
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String[] args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM ;
}
}java对象和类
构造方法
每个类都有构造方法。如果没有显式地定义构造方法，java编译器将会为该类提供一个默认构造方法。
创建对象
在java中使用关键字new来创建一个新的对象。创建对象需要以下三步：
-
声明：声明一个对象，包括对象名称和对象类型
-
实例化：使用关键字new来创建一个对象
-
初始化：使用new创建对象时，会调用构造方法初始化对象
下面是一个创建对象的例子：
public class Puppy{
public Puppy(String name){
//这个构造器仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
// 下面的语句将创建一个Puppy对象
Puppy myPuppy = new Puppy( "tommy" );
}
}
访问实例变量和方法
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();源文件声明规则
-
一个源文件中只能有一个public类
-
一个源文件中可以有多个非public类
-
源文件的名称应该和public类的类名保持一致
-
如果一个类定义在某个包中，那么package语句应该在源文件的首行
-
如果源文件包含 import 语句，那么应该放在 package 语句和类定义之间。如果没有 package 语句，那么 import 语句应该在源文件中最前面。
-
import 语句和 package 语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。
java基本数据类型
内置数据类型
java提供8种基本数据类型。
| 基本类型 | 默认值 |
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| boolean | false |
| char | 'u0000' |
string(or any object) null
引用类型
-
对象，数组都是引用数据类型
-
所用引用数据类型的默认值都是null
java常量
在java中使用final关键字来修饰常量，声明方式和变量类似
final double PI = 3.1415926自动类型转换
转换原则：必须满足转换前的数据类型的位数要低于转换后的数据类型
强制类型转换
byte b = (byte)a
隐含强制类型转换
-
整数的默认类型是 int。
-
小数默认是 double 类型浮点型，在定义 float 类型时必须在数字后面跟上 F 或者 f。
Java变量类型
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。-
静态变量或类变量：类变量是在类中用static关键字声明的变量，他们属于类而不是实例，所有该类的实例共享同一个类变量的值，类变量在类加载时被初始化，而且只初始化一次。
public class ExampleClass {
static int classVar; // 类变量
}-
局部变量：方法里面
-
成员变量：不在方法里面，但在类里面
-
静态变量或类变量：不在方法里面，但在类里面，并使用static修饰
-
参数变量：参数是方法或构造函数声明中的变量，用于接收调用该方法或构造函数时传递的值，参数变量的作用域只限于方法内部。public void method(int param){} , param为参数变量
例子
public class RunoobTest {
// 成员变量
private int instanceVar;
// 静态变量
private static int staticVar;
public void method(int paramVar) {
// 局部变量
int localVar = 10;
// 使用变量
instanceVar = localVar;
staticVar = paramVar;
System.out.println("成员变量: " + instanceVar);
System.out.println("静态变量: " + staticVar);
System.out.println("参数变量: " + paramVar);
System.out.println("局部变量: " + localVar);
}
public static void main(String[] args) {
RunoobTest v = new RunoobTest();
v.method(20);
}
}java参数变量
方法参数变量的值传递方式有两种：值传递和引用传递
-
值传递：在方法调用时，传递的是实际参数的值的副本。当参数变量被赋予新的值时，只会修改副本的值，不会影响原始值。java中基本数据类型都是采用值传递方式传递参数变量的值
-
引用传递：在方法调用时，传递的时实际参数的引用（即内存地址）。当参数变量被赋予新的值时，会修改原始值的内容。java中的对象类型采用引用传递方式传递参数变量的值。
注：基本数据类型采用值传递，对象数据类型采用引用传递。
生命周期
-
局部变量：局部变量的生命周期从声明时开始，到方法、构造方法或代码块执行结束时终止。之后，局部变量将被垃圾回收。
-
成员变量：成员变量在对象创建时被创建，在对象销毁时被销毁
-
类变量（静态变量）：在类加载时被创建，在整个程序运行期间都存在，直到程序结束才会被销毁。静态变量可以用来存储整个程序都需要使用的数据，如配置信息，全局变量等。
常量和静态变量的区别
常量也是与类相关的，但它是用 final 关键字修饰的变量，一旦被赋值就不能再修改。与静态变量不同的是，常量在编译时就已经确定了它的值，而静态变量的值可以在运行时改变。另外，常量通常用于存储一些固定的值，如数学常数、配置信息等，而静态变量通常用于存储可变的数据，如计数器、全局状态等。
总之，静态变量是与类相关的变量，具有唯一性和共享性，可以用于存储整个程序都需要使用的数据，但需要注意初始化时机和与常量的区别。
静态变量的使用场景
-
存储全局状态或配置信息
-
计数器或统计信息
-
缓存数据或共享资源
-
工具类的常量或方法
-
单例模式中的实例变量
public class AppConfig {
public static final String APP_NAME = "MyApp";
public static final String APP_VERSION = "1.0.0";
public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb";
public static void main(String[] args) {
System.out.println("Application name: " + AppConfig.APP_NAME);
System.out.println("Application version: " + AppConfig.APP_VERSION);
System.out.println("Database URL: " + AppConfig.DATABASE_URL);
}
}java变量命名规范
驼峰命名法（Camel Case）： 在变量名中使用驼峰命名法，即将每个单词的首字母大写，除了第一个单词外，其余单词的首字母都采用大写形式。例如：myVariableName。
类名：驼峰命名法，但首字母大写 MyClass
Java修饰符
访问控制修饰符
-
default：在同一包内可见，不使用任何修饰符。使用对象：类，接口，变量，方法
-
private：在同一类内可见，使用对象：变量，方法
-
public：对所有类可见。使用对象：类，接口、变量、方法
-
protected：对同一包内的所有类和子类客键。使用对象：变量，方法。注意：不能修饰外部类
默认访问修饰符-不使用任何关键字
默认访问修饰符的访问级别是包级别（package-level），即只能被同一包中的其他类访问。
非访问修饰符
-
static 修饰符，用来修饰类方法和类变量。
-
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
-
abstract 修饰符，用来创建抽象类和抽象方法。
-
synchronized 和 volatile 修饰符，主要用于线程的编程。
static 修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
final 修饰符
final 变量：
final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
final 修饰符通常和 static 修饰符一起使用来创建类常量。
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";abstract 修饰符
抽象类：抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法。
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}抽象方法
抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
public abstract class SuperClass{
abstract void m(); //抽象方法
}
class SubClass extends SuperClass{
//实现抽象方法
void m(){
.........
}
}synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
public synchronized void showDetails(){
.......
}transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
实例
public transient int limit = 55; // 不会持久化
public int b; // 持久化
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。
但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。
Java运算符
-
条件运算符：b = (a == 1) ? 20 : 30
-
instanceof 运算符：该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
java循环结构
while
public class Test {
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
do/while 语句至少会执行循环一次。
如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。
public class Test {
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 );
}
}for
public class Test {
public static void main(String[] args) {
for(int x = 10; x < 20; x = x+1) {
System.out.print("value of x : " + x );
System.out.print("\n");
}
}
}增强for循环
for(声明语句：表达式)
public class Test {
public static void main(String[] args){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}break
跳出循环
public class Test {
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
// x 等于 30 时跳出循环
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}continue
立即跳转到下一次迭代
public class Test {
public static void main(String[] args) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}java条件语句
if
else if
else
java switch case语句
switch(expression){
case value1:
//语句
break;
case value2:
//语句
break;
default:
//语句
}public class Test {
public static void main(String args[]){
int i = 5;
switch(i){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
default:
System.out.println("default");
}
}
}编译结果为：default
如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。
如果当前匹配成功的 case 语句块没有 break 语句，则从当前 case 开始，后续所有 case 的值都会输出，如果后续的 case 语句块有 break 语句则会跳出判断。
string类
String创建的字符串存储在公共池中，而new创建的字符串对象在堆上
注意:String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了
-
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
| 字符串长度 | string.length() |
| 连接字符串 | string1.concat(string2) |
| 指定索引处的char值 | charAt(int index) |
| 指定字符在此字符串中第一次出现的索引 | indexOf(int ch) |
| 字符串在此字符串中第一次出现处的索引，从指定的索引开始 | |
| 给定正则表达式的匹配拆分此字符串 | |
| 判断字符串是否为空 |
Java StringBuffer 和 StringBuilder 类
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuild
public class RunoobTest{
public static void main(String args[]){
StringBuilder sb = new StringBuilder(10);
sb.append("Runoob..");
System.out.println(sb);
sb.append("!");
System.out.println(sb);
sb.insert(8, "Java");
System.out.println(sb);
sb.delete(5,8);
System.out.println(sb);
}
}
StringBuffer
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer);
}
}
数组
public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("总和为： " + total);
}
}For-Each 循环
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
多维数组
String[][] str = new String[3][4];数组排序
-
Arrays.sort()：Java提供的内置方法，用于对数组进行排序。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] array = {4, 3, 5, 1, 2};
Arrays.sort(array);
System.out.println(Arrays.toString(array)); // 输出：[1, 2, 3, 4, 5]
}
}
-
Collections.sort()：适用于List集合，可以对List集合进行排序。
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(4, 3, 5, 1, 2);
Collections.sort(list);
System.out.println(list); // 输出：[1, 2, 3, 4, 5]
}
}
Java日期时间
import java.util.Date;
public class DateDemo{
public static void main(String[] args){
Date date = new Date();
System.out.println(date.toString());
}
}使用 SimpleDateFormat 格式化日期
import java.util.*;
import java.text.*;
public class DateDemo {
public static void main(String[] args) {
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));
}
}Thread.sleep(1000*3); //休眠3sjava正则表达式
正则表达式工具：
https://www.runoob.com/java/java-regular-expressions.htmlJava方法
方法的重载
一个类两个方法拥有相同的名字，但是有不同的参数列表。重载的方法必须拥有不同的参数列表
public static int max(int num1, int num2) {
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
}构造方法
当一个对象被创建的时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
// 一个简单的构造函数
class MyClass {
int x;
// 以下是构造函数
MyClass(int i ) {
x = i;
}
}可变参数
double... numbers
finalize()方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
Java异常处理
-
检查性异常
try {
// 可能会抛出异常的代码
} catch (IOException e) {
// 处理异常的代码
}-
运行时异常
try {
// 可能会抛出异常的代码
} catch (NullPointerException e) {
// 处理异常的代码
}java提供了以下关键字和类来支持异常处理：
-
try：用于包裹可能抛出异常的代码块
-
catch：用于捕获异常并处理异常的代码块
-
finally：用于包含无论是否发生异常都需要执行的代码块
-
throw：用于手动抛出异常
-
throws：用于在方法声明中指定方法可能抛出的异常
-
Exception类：所有异常的父类，提供了一些方法来获取异常信息
异常处理的最佳实践：
-
在合适的位置捕获异常，并对异常进行适当的处理，以确保程序的稳定性和可靠性。
-
避免过度捕获异常，应该尽量精确捕获特定类型的异常。
-
使用finally块来释放资源，例如关闭文件或数据库连接等，以确保资源的正确释放。
-
优先处理受检异常，避免将受检异常转换为非受检异常。
继承
Java 继承 | 菜鸟教程
-
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
-
extends关键字：一个子类只能拥有一个父类
-
implements关键字：可以同时继承多个接口
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}super关键字与this关键字
-
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
-
this关键字：指向自己的引用。
final关键字
-
final关键字
-
final class 类名
-
Override/Overload
多态
抽象类
封装
接口
枚举
包
Java数据结构
数组（Arrays）
int[] array = new int[5];列表（Lists）
List<String> arrayList = new ArrayList<>(); // 动态数组
List<Integer> linkList = new LinkList<>(); // 双向列表ArrayList
import java.util.ArrayList;
import java.util.Collections;
public class RunoobTest{
ArrayList<String> sites = new ArrayList<String>(); //初始化
sites.add("Google"); // 添加元素
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
System.out.println(sites.get(1));//访问元素
sites.set(2,"Wiki"); //修改元素
sites.remove(3); // 删除元素
System.out.println(sites.size()); //计算大小
//遍历迭代数组
for(int i=0;i<sites.size();i++){
System.out.println(sites.get(i));
}
Collections.sort(sites); // 排序
for(string site:sites){
System.out.println(site);
}
}LinkedList
import java.util.LinkedList;
public class RunoobTest{
public static void main(String[] args){
LinkedList<String> sites = new LinkedList<String>(); //初始化
sites.add("Google"); //添加数据
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
sites.addFirst("Wiki"); //在头部添加数据
sites.addLast("Kuaishou"); // 在尾部添加数据
sites.removeFirst(); //移除头部数据
sites.removeLast(); // 移除尾部数据
System.out.println(sites.getFirst()); // 获取头部元素
System.out.println(sites.getLast()); // 获取尾部元素
System.out.println(sites.size()); // 获取大小
for(int i=0;i<sites.size();i++){
System.out.println(sites.get(i)); // 获取数据
}
for(String site:sites){
System.out.println(site); // for-each获取数据
}
}
}集合
Set<String> hashSet = new HashSet<>(); //无序集合
Set<Integer> treeSet = new TreeSet(); //有序集合hashSet
import java.util.HashSet;
public class RunoobTest{
public static void main(String[] args){
HashSet<String> sites = new HashSet<String>();
sites.add("Google");
sites.add("Google"); //重复元素不会重复添加
bool isContain = sites.contains("Google"); // 判断集合中是否存在某元素，true
sites.remove("Taobao"); // 移除元素，移除成功返回true，移除失败返回false
sites.clear(); // 删除集合中所有元素
System.out.println(sites.size());// 获取数量
for(String site:sites){
System.out.println(site); // for-each遍历
}
}
}映射
Map<String,Integer> hashMap = new HashMap<>(); //基于哈希表实现的键值对存储结构
Map<String,Integer> treeMap = new TreeMap<>(); //基于红黑树实现的有序键值对HashMap
import java.util.HashMap;
public class RunoobTest{
public static class main(String[] args){
HashMap<Integer,String> Sites = new HashMap<Integer,String>();
Sites.put(1,"Google"); //添加元素
Sites.put(2,"Runoob");
Sites.remove(1); // 移除元素
Sites.clear(); // 移除map中所有的元素
s = Sites.size(); // 计算大小
//输出所有的key和value
for(Integer i:Sites.keySet()){
System.out.println("key:"+i+"value:"+Sites.get(i));
}
//返回所有的value
for(String value:Sites.values()){
System.out.print(value+",");
}
}
}hashMap entrySet()方法
hashmap.entrySet()： 返回映射中包含的映射的Set视图
import java.util.HashMap;
class Main{
HashMap<Integer,String> sites = new HashMap<>();
sites.put(1,"Google");
sites.put(2,"Runoob");
sites.put(3,"Taobao");
System.out.println("sites HashMap"+sites());
System.out.println("Set View:"+sites.entrySet());
}
entrySet() 方法可以与 for-each 循环一起使用，用来遍历迭代 HashMap 中每一个映射项。
栈
Stack<Integer> stack = new Stack<>();队列
Queue<String> queue = new LinkList<>();Java Iterator
java迭代器：
-
next() : 返回迭代器的下一个元素，并将迭代器的指针移到下一个位置
-
hasNext(): 用于判断集合中是否还有下一个元素可以访问
-
remove() : 从集合中删除迭代器最后访问的元素
import java.util.ArrayList;
import java.util.Iterator;
public class RunoobTest{
public static void main(String[] args){
ArrayList<String> sites = new ArrayList<String>();
sites.add("Google");
sites.add("Runoob");
//获取迭代器
Iterator<String> it = sites.iterator();
System.out.println(sites.next());
//循环遍历
while(it.next()){
System.out.println(sites.next());
}
while(it.next()){
String i = it.next();
if(i=="Runoob"){
it.remove();
}
}
}
}Java Object类
java object类是所有类的父类，也就是java所有的类都继承了Object，子类所有使用Object的所有方法
-
显式继承:
public class Runoob extends Object{
}-
隐式继承
public class Runoob {
}Java泛型
-
解决问题：假定我们有这样一个需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
public class GenericMethodTest
{
// 泛型方法 printArray
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
public static void main( String args[] )
{
// 创建不同类型数组： Integer, Double 和 Character
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println( "整型数组元素为:" );
printArray( intArray ); // 传递一个整型数组
System.out.println( "\n双精度型数组元素为:" );
printArray( doubleArray ); // 传递一个双精度型数组
System.out.println( "\n字符型数组元素为:" );
printArray( charArray ); // 传递一个字符型数组
}
}类型通配符
1、类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。
Java序列化
-
java序列化是一种将对象转换为字节流的过程
-
java反序列化是将字节还原成对象
序列化对象
import java.io.*;
public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;
try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
}
}反序列化
import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}Json
public void testJson(){
JsonObject object = new JsonObject();
object.put("string","string");
object.put("int",2);
object.put("boolean",true);
//array
List<Integer> integers = Arrays.asList(1,2,3);
object.put("list",integers);
//null
object.put("null",null);
System.out.println(object);
}
解码
public void testJson2(){
JSONObject object = JSONObject
.parseObject("{\"boolean\":true,\"string\":\"string\",\"list\":[1,2,3],\"int\":2}");
//string
String s = object.getString("string");
System.out.println(s);
//int
int i = object.getIntValue("int");
System.out.println(s);
//boolean
boolean b = object.getBooleanValue("boolean");
System.out.println(b);
//list
List<Integer> integers = Json.parseArray(object.getJsonArray("list").toJsonString(),Integer.class);
integers.forEach(System.out::println);
//null
System.out.println(object.getString("null"));
}
Json对象和字符串互相转化
| 方法 | 作用 |
| Json.parseObject() | 从字符串中解析json对象 |
| Json.parseArray() | 从字符串中解析json数组 |
| Json.toJsonString(obj/array) | 将json对象或json数组转化为字符串 |
//从字符串解析JSON对象
JSONObject obj = JSON.parseObject("{\"runoob\":\"菜鸟教程\"}");
//从字符串解析JSON数组
JSONArray arr = JSON.parseArray("[\"菜鸟教程\",\"RUNOOB\"]\n");
//将JSON对象转化为字符串
String objStr = JSON.toJSONString(obj);
//将JSON数组转化为字符串
String arrStr = JSON.toJSONString(arr);Java8 新特性
stream
-
stream(): 为集合创建串行流
-
parallelStream() : 为集合创建并行流
List<String> strings = Arrays.asList("abc","","bc","efg","abcd","","jkl");
List<String> filtered = strings.stream().filter(string->!string.isEmpty()).collect(Collectors.toList());forEach
forEach迭代流中的每个数据
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);map
map方法用于映射每个元素对应的结果
List<Integer> numbers = Arrays.asList(3,2,2,3,7,3,5);
List<Integer> squaresList = numbers.stream().map(number->number*number).distinct().collect(Collector.toList());filter
filter用于过滤元素
List<String>strings = Arrays.asList("abc","","bcd");
long count = strings.stream().filter(string->string.isEmpty()).count();limit
limit用于获取指定数量
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);打印10条数据
sorted
Random random = new Random();
random.ints().limit(10).sorted.forEach(System.out::println);parallel
parallelStream: 流并行处理
List<String> strings = Arrays.asList("abc","","abc");
long count = strings.parallelStream().filter(string->string.isEmpty()).count();Collectors
collectors 类实现很多归约操作，例如将流转换成集合和聚合元素。Collectors可用于返回列表或字符串
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());
System.out.println("筛选列表: " + filtered);
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(", "));
System.out.println("合并字符串: " + mergedString);统计
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());
IntStream.rangeClosed(portStart, portEnd).forEach(ports::add);
多线程
HandleContext context = new HandleContext();
//allPorts v 中的 size 都加一起
context.setPortCount(new AtomicInteger());
allPorts.values().stream().map(Set::size).forEach(context.getPortCount()::addAndGet);
标签：java,变量,基础,System,String,println,public,out From： https://blog.csdn.net/weixin_43527195/article/details/142438754