可以有多少个简单java类呢_java几个类的简单使用

Random

Random类用来创建一个新的随机数生成器。

对象数组

ArrayList集合的长度是可以随意改变的。

ArrayList这个代表泛型

泛型：装在集合当中的所有元素，全部都是统一的类型。泛型只能是引用类型，不能使用基本元素。

import java.util.ArrayList;

public class ArrayListExercise {

public static void main(String[] args) {

ArrayList list = new ArrayList<>();

list.add("盖伦");

list.add("锐雯");

list.add("亚索");

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

}

}

boolean add(E e)

E get(int index)

E remove(int index)

int size()

ArrayList集合中存储基本数据类型时，必须使用基本数据类型对应的包装类。

基本类型

包装类

byte

Byte

short

Short

int

Integer

long

Long

double

Double

char

Character

boolean

Boolean

字符串

Java程序中的所有的字符串字面值(“ABC”)都作为此类的实例实现。

字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。

字符串的构造方法和直接创建

public class StringExercise {

public static void main(String[] args) {

//使用空参构造

String string1 = new String();

System.out.println(string1);

//使用字符数组构造

char[] chars = {'A','B','C'};

String string2 = new String(chars);

System.out.println(string2);

//使用字节数组构造

byte[] bytes = {97,98,99};

String string3 = new String(bytes);

System.out.println(string3);

//直接创建

String string4 = "hello";

System.out.println(string4);

}

}

字符串常量池

程序当中直接写上的双引号字符串，就在字符串常量池中。

倒叙遍历

import java.util.Arrays;

public class ArraysExercise {

public static void main(String[] args) {

String string = "abdsdafawaswa";

char[] chars = string.toCharArray();

Arrays.sort(chars);

//chars.fori快捷

for (int i = 0; i < chars.length; i++) {

System.out.println(chars[i]);

}

//chars.forr快捷

for (int i = chars.length - 1; i >= 0; i--) {

System.out.println(chars[i]);

}

}

}

改写Object类中的toString和equals方法

import java.util.Objects;

public class Person {

private String name;

private int age;

@Override

public String toString() {

//对toString方法进行重写，使可以输出自己想要输出的内容，而不再输出对应对象的地址

return "Person{" + "name:" + name + ",age:" + age + "}";

}

/*

Object类的equals方法，默认比较的是两个对象的地址值，没有意义

可以进行重写，比较的内容自己设置

问题：

1、隐含一个多态

2、多态的弊端：无法使用子类特有的内容(属性和方法)

解决：可以使用向下转型把obj类型转换为自己定义的类型

*/

// @Override

public boolean equals(Object obj) {

if(obj == this){

return true;

}

if(obj == null){

return false;

}

//向下转型

if(obj instanceof Person){

Person person = (Person)obj;

//比较两个对象的属性，一个为this，一个为转换的对象。

return this.name.equals(person.name) && this.age == person.age;

}

return false;//不是对应的类型，直接返回false

}

@Override

public boolean equals(Object o){

if(this == o) return true;

//getClass() != o.getClass()使用反射技术，判断o是否是Person类型，

//等效于obj instanceof Person

if(o == null || getClass() != o.getClass()) return false;

Person person = (Person)o;

return age == person.age && Objects.equals(name,person.name);

//Objects.equals()方法会放在空指针异常(null)

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

public class ObjExercise {

public static void main(String[] args) {

Person person1 = new Person("sunwu",20);

Person person2 = new Person("huayue",22);

System.out.println(person1);

System.out.println(person2);

boolean bool = person1.equals(person2);

System.out.println(bool);

}

}

Data类

import java.util.Date;

public class DateExercise {

public static void main(String[] args) {

System.out.println(System.currentTimeMillis());

demoOne();

demoTwo();

demeThree();

}

private static void demeThree() {

Date data = new Date();

System.out.println(data.getTime());

}

public static void demoOne(){

Date date = new Date();

System.out.println(date);

}

public static void demoTwo(){

Date date = new Date(1583560500337L);

System.out.println(date);

}

}

DateFormat(抽象类)

格式化(日期-->文本)、解析(文本-->日期)

SimpleDateFormat类

构造方法：

SimpleDateFormat(String pattern)用给定的模式和默认环境的日期格式符号构造SimpleDateFormat

参数pattern：传递指定的模式

y年M月d日H时m分s秒

写对应的模式，会把模式替换为对应的日期和时间

"yyyy--MM-dd HH:mm:ss"，连接发符号可以改变

format(Date date)按照指定的模式，吧Date日期格式化为符号模式的字符串

parse(String source)把符号模式的字符串解析为date日期

parse声明了一个异常parseException，如果字符串和构造方法的模式不一样，那么程序就会抛出异常。这里采用不处理只声明异常的方法 throws ParseException

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class SimpleDateFormatExercise {

public static void main(String[] args) throws ParseException {

//demoOne();

demoTwo();

}

private static void demoTwo() throws ParseException {

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd HH:mm:ss" );

Date date = simpleDateFormat.parse("2020--03--07 23:07:52");

System.out.println(date);

//如果解析的字符串与格式不一样，就会抛出异常。

}

private static void demoOne(){

SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd HH:mm:ss" );

Date date = new Date();

String dateFormat = simpleDateFormat.format(date);

System.out.println(date);

System.out.println(dateFormat);

}

}

Calendar类：日历类(是一个抽象类)，里面有很多操作日历字段的方法

Calendar类无法直接创建对象，里面有一个静态方法叫getInstance()，该方法返回了Calendarr类的子类对象。

常用的成员方法

1、 pubilc int get(int field)：返回给定日历字段的值

2、 pubilc void set(int field ,int value):将给定的日历字段设置为给定值

3、 public abstract void add(int field, int amout):根据日历的规则，为给定的日历字段添加或减去指定的时间量

4、 pubilc Date getTime():返回一个表示此Calendar时间值的Date对象

int field:日历类的字段，可以使用Calendar类的静态变量获取

YEAR = 1 年

MONTH = 2 月

DATE = 5 日

DAY_OF_MONTH = 5 月中的某一天

HOUR = 10 时

MINUTE = 12 分

SECOND = 13 秒

Calendar calendar = Calendar.getInstance();//多态(重点关注)

import java.util.Calendar;

import java.util.Date;

public class CalendarExercise {

public static void main(String[] args) {

//Calendar calendar = Calendar.getInstance();//多态

//System.out.println(calendar);//从写toString方法

//demoOne();

//demoTwo();

demoThree();

//demoFour();

}

private static void demoFour() {

Calendar calendar = Calendar.getInstance();

Date date = calendar.getTime();

System.out.println(date);

}

private static void demoThree() {

Calendar calendar = Calendar.getInstance();

calendar.add(Calendar.YEAR,2); // 正为加，负为减

calendar.add(Calendar.MONTH,-3);

System.out.println(calendar.get(Calendar.YEAR));

System.out.println(calendar.get(Calendar.MONTH));

}

private static void demoTwo() {

Calendar calendar = Calendar.getInstance();

calendar.set(Calendar.YEAR,9999); // 设置日期

//calendar.set(888,88,88);

System.out.println(calendar.get(Calendar.YEAR));

}

private static void demoOne() {

Calendar calendar = Calendar.getInstance();

int year = calendar.get(Calendar.YEAR);

System.out.println(year);

int month = calendar.get(Calendar.MONTH);//西方是0-11

System.out.println(month);

int dateOfMonth = calendar.get(Calendar.DAY_OF_MONTH);

System.out.println(dateOfMonth);

}

}

System.CurrentTimeMillis()方法

public class CurrentTimeMillisExercise {

public static void main(String[] args) {

demoOne();

}

private static void demoOne() {

long start = System.currentTimeMillis(); //获取毫秒值

for (int i = 0; i <9999; i++) {

System.out.println(i);

}

long end = System.currentTimeMillis();

System.out.println("\n程序运行时间：" + (end-start) + "毫秒");

}

}

System.arraycopy(……)

System.arraycopy(object src,int srcPos,object dest,intdestPos,int length)：将数组中指定的数据拷贝到另一个数组

src：原数组

srcPos：原数组中的起始位置(索引)

dest：目标数组

destPos：目标数组中的起始位置

length：要复制的长度

import java.util.Arrays;

public class ArrayCopyExercise {

public static void main(String[] args) {

demo();

}

private static void demo() {

int[] src = {1,2,3,4,5};

int dest[] = {6,7,8,9,10};

System.out.println("复制前：" + Arrays.toString(dest));

System.arraycopy(src,0,dest,2,3); //从原数组(目标数组)要复制(被复制)的索引开始 + length <=src.length()/dest.length()

System.out.println("复制后：" + Arrays.toString(dest));

}

}

Stingbuilder

字符串缓冲区支持可变的字符串。

public class StringBuilderExercise {

public static void main(String[] args) {

demoOne();

demoTwo();

demoThree();

demoFour();

}

private static void demoFour() {

String string = "hello";

StringBuilder stringBuilder = new StringBuilder(string);

stringBuilder.append("world");

System.out.println(stringBuilder);

final String string1 = stringBuilder.toString();

System.out.println(string1);

}

private static void demoThree() {

StringBuilder stringBuilderOne = new StringBuilder();

stringBuilderOne.append("hello").append(123456789); // 链式编程

System.out.println(stringBuilderOne);

}

private static void demoTwo() {

//带参构造

StringBuilder stringBuilder = new StringBuilder("hello");

System.out.println(stringBuilder);

}

private static void demoOne() {

//空参构造方法

StringBuilder stringBuilder = new StringBuilder();

System.out.println(stringBuilder);

}

}

装箱和拆箱

装箱：基本数据类型-->包装类

拆箱：包装类-->基本数据类型

可以使用构造方法或者使用valueOf方法进行装箱(对字符串类型的数和基本数据类型)。

可以进行自动装箱和自动拆箱

基本数据类型和字符串类型之间相互转换

1、基本数据类型的值 + "" (最简单)

2、包装类的静态方法toString(参数)， 和object是重载关系

3、String类的静态方法valueOf(参数)，将基本数据类型进行转换

1、使用包装类的静态方法parsexxx("数值类型的字符串")