JAVA
Day15
SturingBuffer
替换功能
public StringBuffer replace(int start,int end,String str)
将指定str字符串替换从指定位置开始到指定位置结束（不包含end位置）
public class StringBufferDemo {
public static void main(String[] args) {
//创建一个字符串缓冲区对象
StringBuffer sb = new StringBuffer() ;
//添加元素
sb.append("hello") ;
sb.append("java") ;
sb.append("wold") ;
//替换public StringBuffer replace(int start,int end,String str)
StringBuffer sb2 = sb.replace(5, 10, "高圆圆") ;
System.out.println("sb2:"+sb2) ;反转功能
public StringBuffer reverse():将字符串缓冲区中的内容进行反转
将StringBuffer转换成String类型
public String toString( )
面试题:
给定一个字符串,如何将字符串进行反转
(使用StringBuffer的reverse功能)
import java.util.Scanner;
public class StringBufferDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//接收
System.out.println("请输入一个字符串:");
String s = sc.nextLine() ;
//创建缓冲区对象
StringBuffer sb = new StringBuffer(s) ;
StringBuffer sb2 = sb.reverse() ;
//输出
System.out.println(sb2.toString());
}
}截取功能
public String substring(int start):从指定位置开始截默认截取到末尾
public String substring(int start,int end):从指定位置开始截取到指定位置结束(不包含end位置)
public class StringBuferDemo3 {
public static void main(String[] args) {
//缓冲区对象创建
StringBuffer sb = new StringBuffer() ;
//添加元素内容
sb.append("hello") ;
sb.append("j"
+ "a"
+ "vaee") ;
// /public String substring(int start)
String s1 = sb.substring(5) ;
System.out.println("s1:"+s1);//javaee
String s2 = sb.substring(0, 6) ;
System.out.println("s2:"+s2);//helloj
}String和StringBufer的转换
/*
* 为什么要说A--B?(引用类型)
* 在实际开发中,在某个功能中可也能要用B类型的数据
* 需要将A类型---->B类型
*
* 其他功能中又需要用到A类型的数据---->B类型--->A类型
* String和StringBuffer的相互转换
* */
public class StringBufferTest {
public static void main(String[] args) {
//String---->StringBuffer类型
//方式1:
String s = "hello" ;
//StringBuffer sb = s ; //错误的
//StringBuffer sb = "hello" ;//错误的
//通过构造方式转换
/*
* StringBuffer sb = new StringBuffer(s) ;
* System.out.println(sb);
*/
//方式2:通过append方法进行追加
//创建一个缓冲区对象
StringBuffer sb = new StringBuffer() ;
sb.append(s) ;
System.out.println(sb);
System.out.println("-----------------------------");
//StringBuffer----String
//方式1:String类型构造函数
//String(StringBuffer buffer)
StringBuffer buffer = new StringBuffer("java") ;
//装饰者设计模式
//StringBuffer buffer = new StringBuffer(new String("java")) ;
String str = new String(buffer) ;
System.out.println(str);
//方式2:public String toString()
String str2 = buffer.toString() ;
System.out.println(str2);
}
}System类：一些有用的类的字段和方法它不能被实例化
成员变量:
- in System.in-- >InputStream:字节输入流 public static final InputStream in:
- out System.out—>PrintStream：字节打印流
成员方法：
- public static void gc()：开启垃圾回收器
- finalize():垃圾回收器来回收不用的对象，及时释放内存！
- final,finalize()的区别?
public static void exit(int status)
public static long currentTimeMillis()
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
//自定义类
public class Person extends Object{
private String name ;
private int age ;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
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;
}
//重写toString()
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
//重写finalize()
@Override protected void finalize() throws Throwable {
System.out.println("垃圾回收器开始回收当前不用的对象了..."+this);
super.finalize();
}
}
public class SystemDemo {
public static void main(String[] args) {
//创建一个Person对象
Person p = new Person("梁侃",28) ;
System.out.println(p);//Person [name=梁侃, age=28]
System.out.println("----------------");
//让p对象为null
p = null ;
System.gc(); //运行垃圾回收器 (jvm本身运行的时候会自动回收不用的对象!)
}
}
- public static void exit(int status)终止当前正在运行的 Java 虚拟机。
参数用作状态码；根据惯例，非 0 的状态码表示异常终止 - public static long currentTimeMillis():获取的是当前系统时间的毫秒值
public class SystemDemo2 {
public static void main(String[] args) {
//System.out.println("今天天气不错...");
//System.out.println("今天常用类的学习...");
//System.exit(0); //强制终止当前java虚拟机
//System.out.println("程序结束了...");
//public static long currentTimeMillis()
//单独使用,没有意义
//System.out.println(System.currentTimeMillis());//1573461200254ms(当前系统时间)
//应用场景:计算某个程序的耗时时间
long start = System.currentTimeMillis() ;
//for循环
for(int x = 0 ; x < 100000; x ++) {
System.out.println("hello"+x);
}
long end = System.currentTimeMillis() ;
System.out.println("当前for循环共耗时:"+(end-start)+"毫秒");//2414毫秒
}
}-
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
从指定源数组中的某个位置开始,到目标数组的某个位置指定一个长度结束,进行数组的元素复制 -
数组操作的工具类:Arrays
-
public static String toString(任何数组):将任意类型的数组---->String [元素1,元素2,…]
import java.util.Arrays;
pubic class SystemDemo3 {
public static void main(String[] args) {
//两个数组
int[] arr = {11,22,33,44,55} ;
int[] arr2 = {6,7,8,9,10} ;
//Arrays.toString()
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
System.out.println("--------------------");
//public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
System.arraycopy(arr, 1, arr2, 2, 2);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arr2));
}
}Random类 ：用于产生随机数的一个类.
构造函数:
-
public Random()创建一个新的随机数生成器。
-
public Random(long seed):通过指定long类型的时间毫秒值数据创建一个随机数生成器
-
每次产生的随机数数据是固定的
成员方法: -
public int nextInt():产生的随机的范围是在int类型范围内容(不用) (默认int类型的范围)
-
public int nextInt(int n):产生一个随机数,范围在[0,n):不包含n (重点 )
如果产生一个随机数,一般使用空参构造函数+带参数的成员方法nextInt(int n)
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建一个Random对象
Random r = new Random() ;
//System.out.println(random);//java.util.Random@7852e922
// Random r = new Random(1111) ;//指定了long类型的数据,每次调用nextInt()/nextInt(int n),随机数是固定的
// System.out.println(r);
//产生10个随机数
for(int x = 0 ; x <10 ; x++) {
//System.out.println(r.nextInt());
System.out.println(r.nextInt(100));//[0,100)
}
}
}math类：用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
常用的成员方法:
public static int abs(int a):求绝对值
public static double ceil(double a):向上取整
public static double floor(double a):向下取整
public static int max(int a,int b) min自学 :求最大值
public static double pow(double a,double b):a的b次幂值
public static double random() :获取随机数[0.0,1.0)) (重点)
public static int round(float a) 参数为double的自学 四舍五入(重点)
public static double sqrt(double a):开平方根
//Math.max(int i,Math.max(int a,int b));
//需求:编程题
// 请设计一个方法,获取任意范围内的随机数!
public class MathDemo {
public static void main(String[] args) {
//求绝对值
System.out.println("abs():"+Math.abs(100.99));
System.out.println("abs():"+Math.abs(-20));
//向上取整
System.out.println("ceil():"+Math.ceil(12.34));
System.out.println("ceil():"+Math.ceil(12.56));
// public static double floor(double a):向下取整
System.out.println("floor():"+Math.floor(12.34));
System.out.println("floor():"+Math.floor(12.56));
// //求最大值
System.out.println("max():"+Math.max(10, 29));
System.out.println("max():"+Math.max(10,Math.max(20, 5)));
//public static double pow(double a,double b):a的b次幂值
System.out.println("pow():"+Math.pow(2, 3));//Math类中默认的值double类型
//public static double random() :获取随机数[0.0,1.0)) (重点)
System.out.println("random():"+Math.random()); //1~100之间随机数
// /public static int round(float a) 参数为double的自学 四舍五入(重点)
// public static double sqrt(double a):开平方根
System.out.println("round():"+Math.round(12.56));
System.out.println("round():"+Math.round(12.34));
System.out.println("sqrt():"+Math.sqrt(16));
}
}
Integer类
-
jdk1.5以后自动拆装箱
int------>Integer 有时需要将int---->String/String—>int (Integer类型中作为桥梁) -
char----->Character
-
byte----->Byte
-
short---->Short
-
long----->Long
-
float---->Float
-
double—>Double
-
boolean---->Boolean
Integer： -
成员变量（字段：Field）
-
public static final int MIN_VALUE；
-
public static final int MAX_VALUE；
进制相关的成员方法
- public static String toBinaryString(int i):二进制
- public static String toHexString(int i)：十六进制
- public static String toOctalString(int i)：八进制
/*
* 需求：
* int类型的范围？
* 快速求出100的二进制，八进制，十六进制*/
public class IntegerDemo {
public static void main(String[] args) {
//输出int类型的访问
System.out.println(Integer.MIN_VALUE);//-2147483648
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println("----------------------------------");
//进制
System.out.println(Integer.toBinaryString(100));//1100100
System.out.println(Integer.toOctalString(100));//144
System.out.println(Integer.toHexString(100));//64
}
}构造方法：
- public Integer(int value) ：通过int类型数据构造成Integer对象
- public Integer(String s)：通过String类型数据构成成Integer对象
public class IntegerDemo2 {
public static void main(String[] args) {
//创建一个Integer对象
Integer i = new Integer(100) ;//--->Integer i = 100;
System.out.println(i);//100 -->Integer
// java.lang.NumberFormatException:数据格式化异常
//Integer ii = new Integer("hello") ;
//注意事项：Integer(String s):传递的是一个数字字符串 “100” ，“10”
Integer ii = new Integer("10") ;
System.out.println(ii);
}
}
dk1.5以后对于基本类型是可以引用类型相互转换：
- 自动拆装箱
- 拆箱：将包装类类型---->基本数据类型
- 装箱：将基本数据类型---->包装类类型
public class IntegerDemo3 {
public static void main(String[] args) {
//定义一个Integer类型的数据
Integer i = 100 ;//-->通过valueOf(100)
i += 200;
System.out.println(i);
}
}
/*
*
* 反编译工具查看：
* Integer i = Integer.valueOf(100);//自动装箱
i = Integer.valueOf(i.intValue() + 200); //先是自动拆箱 intValue()---->计算出结果--->将结果装箱
System.out.println(i);//输出当前Integer对象
* */String类和int类型之间的相互转换
- int–>String
String的valueOf(int i) ; - String–int String-(Long)–long :public static long parseLong(String s)
public static int parseInt(String s)
public class IntegerDemo4 {
public static void main(String[] args) {
//int----->String
//定义int类型变量
int i = 100 ;
//方式1：字符串拼接
String s = "" ;
String s2 = s+i ;
System.out.println(s2);
System.out.println("--------------------");
//方式2:String类型的valueOf(int number) ;
String s3 = String.valueOf(i) ;
System.out.println(s3);
System.out.println("--------------------");
//方式3:int---->Integer----->String (Integer的构造函数)
Integer ii = new Integer(i) ;
//Integer的toString()方法
String s4= ii.toString() ;
System.out.println(s4);
System.out.println("--------------------");
//定义了一个字符串
String str = "10" ;
//方式1:String--->Integer--->int
//构造函数Integer(String s) :
Integer iii = new Integer(str) ;
//Integer--->int
//public int intValue()
int a = iii.intValue() ;
System.out.println(a);
System.out.println("--------------------");
//方式2:parseInt() ;
//public static int parseInt(String s) throws NumberFormatException
int b = Integer.parseInt(str) ;
System.out.println(b);
}
}Date类：Date 表示特定的瞬间，精确到毫秒
构造函数:
- public Date():创建一个Date日期对象,系统的时间毫秒值
*public Date(long date):传入指定的时间毫秒值,指定的是1970-1-1 以来的指定毫秒数。
成员方法 - public long getTime():获取的系统时间毫秒值
- public void setTime(long time):设置一个时间毫秒值
(表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点)
import java.util.Date;
public class DateDemo {
public static void main(String[] args) {
//创建一个Date对象
Date d = new Date() ;
System.out.println(d);//Mon Nov 11 16:54:34 CST 2019
//getTime();
//System.out.println(d.getTime()); //系统时间毫秒值 跟1970年1月1日
//public static long currentTimeMillis()
//System.out.println(System.currentTimeMillis());//1573462841301
//给定一个时间
long time = 1000*60*60 ; //1小时
//Date d = new Date(time) ;
//System.out.println(d);//Thu Jan 01 09:00:00 CST 1970
d.setTime(time);
System.out.println(d);
}
} Date日期格式----如何转换成"日期文本"格式
DateFormat:日期格式化类,属于java.text.包下的抽象类
-
可以将日期格式—>“文本格式” 格式化过程
-
将"文本格式"----->日期格式 解析
-
DateFormat df = new DateFormat(); //不能实例化
必须使用子类实例化
SimpleDateFormat
日期和时间模式 -
y 年 1999年 yyyy
-
M 年中的月份 11月/02 MM
-
d 月份中的某一天 11日/05日 dd
-
H 时
-
m 分
-
s 秒
构造方法
- public SimpleDateFormat(String pattern)
- pattern:yyyy-MM-dd
yyyy年MM月dd日 - 成员方法
- public final String format(Date date):格式化 :Date转换成String
- public Date parse(String source) throws ParseException:解析:String—>Date
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo2 {
public static void main(String[] args) throws ParseException {
//将日期格式转换成"文本格式"
//创建日期对象
Date d = new Date() ;
//使用中间桥梁:SimpleDateFormat
//创建SimpleDateFormat对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss") ;
//public final String format(Date date)
String s = sdf.format(d) ;
System.out.println(s);
System.out.println("--------------------");
//String---->Date 解析
String str = "2019-11-11" ;
//创建SimpleDateFormat对象
//模式必须要字符串的模式一致,否则报错 (parseException)
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd") ;
Date d2 = sdf2.parse(str) ; //编译异常
System.out.println(d2);//Mon Nov 11 00:00:00 CST 2019
}
}Character类: 包装一个基本类型 char 的值
构造函数:
public Character(char value)
pblic class CharacterDemo {
public static void main(String[] args) {
//创建一个Character对象
// Character ch = new Character((char)97) ;
Character ch = new Character('a') ;
System.out.println(ch);//a
}
}
判断功能
public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
public static boolean isDigit(char ch):判断给定的字符是否是数字字符
public static char toUpperCase(char ch):将给定的字符转成大写
public static char toLowerCase(char ch):将给定的字符转成小写
helloWorld123Java
每一个字符的范围’a’~‘z’
public class CharacterDemo2 {
public static void main(String[] args) {
//public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
System.out.println("isUpperCase():"+Character.isUpperCase('A'));//true
System.out.println("isUpperCase():"+Character.isUpperCase('a'));
System.out.println("isUpperCase():"+Character.isUpperCase('0'));
System.out.println("-----------------------------------------");
//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
System.out.println("isLowerCase():"+Character.isLowerCase('A'));
System.out.println("isUpperCase():"+Character.isLowerCase('a'));
System.out.println("isUpperCase():"+Character.isLowerCase('0'));
System.out.println("-----------------------------------------");
// public static boolean isDigit(char ch):判断给定的字符是否是数字字符
System.out.println(Character.isDigit('A'));
System.out.println(Character.isDigit('a'));
System.out.println(Character.isDigit('0'));
System.out.println("-----------------------------------------");
//public static char toUpperCase(char ch):将给定的字符转成大写
System.out.println(Character.toUpperCase('a'));//A
System.out.println(Character.toLowerCase('A'));//a
}
}案例（Character 结合统计）
import java.util.Scanner;
/*
* 使用Character类的判断功能改进:
* 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
*
* 分析:
* 1)创建键盘录入对象
* 2)录入字符串数据
* 3)将字符串转换成字符数组 toCharArray()
* 4)遍历字符数组
* char ch = 数组名称[角标] ; ---->char类型---->自动装箱为Character类型
* 5)使用Character(char ch)
*
* */
public class CharacterTest {
public static void main(String[] args) {
//定义三个统计变量
int bigCount = 0;
int smallCount = 0 ;
int numberCount = 0;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//接收
System.out.println("请您输入一个字符串数据:");
String line = sc.nextLine() ;
//将字符串转换成字符数组
char[] chs = line.toCharArray() ;
//遍历
for(int x = 0 ; x < chs.length ;x ++) {
//获取每一个字符
char ch = chs[x] ;
//判断
if(Character.isUpperCase(ch)) {//如果是大写字母字符
bigCount ++ ;
}else if(Character.isLowerCase(ch)) {
smallCount ++ ;
}else if(Character.isDigit(ch)) {
numberCount++;
}
}
System.out.println("大写字母字符共有:"+bigCount+"个");
System.out.println("小写字母字符共有:"+smallCount+"个");
System.out.println("数字字符共有:"+numberCount+"个");
}
}
面试题：
数组,StingBuffer,集合 三者之间区别? （重点）
共同点：都是容器，都可以存储元素
区别：
数组：长度固定，并且只能存储同一类型的元素，如果长度再次变化，如果使用数组麻烦！
StringBuffer：在内存中是以字符串缓冲区存在的，里面只能存储字符串数据
长度是可以不断的在字符串末尾追加
集合：（使用居多）
长度：
长度是可变的！
存储类型：
只能存储引用类型数据
存储元素：
可以存储不同类型的元素
StringBuffer,StringBuilder的区别?
线程角度：
StringBuffer，线程安全，同步，执行效率低
StringBuilder,线程不安全，不同步，执行效率高
概念：
单线程程序中（main：主线程）StringBuilder替代StringBuffer
StringBuilder和StingBuffer都是可变字符序列，兼容的API
面试题：
Integer i = 1;
i += 1;做了哪些事情
第一步:Integer i = 1 ; ----->自动装箱 Integer i = Integer.valueOf(1) ;
第二步:i+=1;------>i= Integer.valueOf(i.intValue()+1)
将Integer类型的i拆箱位int基本类型,然后1做运算,结果int类型,再次进行装箱
---->Integer类型
System的exit(int status):
status:状态码
0:终止jvm
B/S结构:Browser 浏览器 和 Server服务器端
200:浏览器发送请求,服务器端响应成功
404:访问内容不存在或者浏览时的路径有问题
500:浏览器发送请求,服务器解析数据的时候出现问题
302:重定向
（考虑：高并发，海量数据，高负载） 并行
服务器：
http服务器 nginx（理论并发访问呢：5w）
web服务器：tomcat（理论并发访问：500个）