一、字符串缓冲区.
1.1面试题
String和StringBuffer 和StringBuilder区别
字符串String可以创建字符串对象，创建的字符串对象是常量，字符串对象一旦创建字符序列不能更改
StringBuffer 和StringBuilder是字符串缓冲区
相同点：都可以存放字符串
不同点
1.String字符串对象一旦创建字符串序列不可以更改
2.StringBuffer和StringBuilder字符串创建后字符串序列可以更改
StringBuffer和StringBuilder的区别
1.版本不同： StringBuffer jdk1.0 StringBuilder jdk1.5
2.是否支持多线程
StringBuffer 支持多线程 线程安全 效率低
StringBuilder 不支持多线程支持单线程 线程不安全 效率高
1.2概念
*字符串缓冲区：StringByffer+StringBuilder
*字符串String:String创建的对象是常量：：：字符串对象一旦创建字符序列不能更改
*在进行字符串拼接时，会在内存中形成好多个字符串对象
*字符串缓冲区：字符串序列可以更改
*字符串缓冲区：字符创建后，字符序列可以更改
*字符串缓冲区：StringBuffer StringBuilder是等价类(api兼容，方法完全相同)
*区别:版本不能不同:StringBuffer jdk1.0 StringBuilder jdk1.5
*是否支持多线程：StringBuffer支持多线程 安全 效率低
StringBuilder支持单线程 不安全 效率高
1.3构造方法
//StringBuffer构造方法
//StringBuffer() 1.创建一个空序列的字符串缓冲区
StringBuffer stb1 = new StringBuffer();
//StringBuffer(String)2.创建一个与参数字符串相同序列的字符串缓冲区
StringBuffer stb2 = new StringBuffer("1223455");
//StringBuffer与String相同的方法
//1.char charAt(int index):获取参数下标处的字符
System.out.println(stb2.charAt(2));
//2.int indexOf(String str):获取str第一次出现的位置
System.out.println(stb2.indexOf("5"));
//int indexOf(String str,int fromIndex):从fromIndex位置处开始找获取str第一次出现的位置
System.out.println(stb2.indexOf("2", 1));
//int lastIndex(String str):倒着找
System.out.println(stb2.lastIndexOf("2"));
//int lastIndexOf(String str,int fromIndex):倒着找
System.out.println(stb2.lastIndexOf("5", 8));
//3.int length():获取字符个数
System.out.println(stb2.length());
//4.String substring(int start,int end)截取从start-end-1处的子串
System.out.println(stb2.substring(1, 3));//22
1.4普通方法
StringBuffer stb3=new StringBuffer("Hello");
//StringBuffer特有的普通方法
//1.StringBUffer append(Object obj):字符串拼接，返回的是当前对象
stb3.append("World");
System.out.println(stb3);//HelloWorld
//字符串缓冲区不能用连接符
//stb3.append("1").append(1).append(true);//可以轻松实现方法链
System.out.println(stb3);//HelloWorld11true
//2.StringBuffer delete(int start,int end)删除start到end-1处的字符
stb3.delete(1, 3);
System.out.println(stb3);//HloWorld
//3.StringBuffer deleteCharAt(int index)删除指定下标出的字符
System.out.println(stb3.deleteCharAt(3));//Hloorld
//4.StringBuffer insert(int offset,Object o):在 offset位置处插入o
System.out.println(stb3.insert(1, "e"));//Heloorld
System.out.println(stb3.insert(2, "l"));//Helloorld
System.out.println(stb3.insert(5, "W"));//HelloWorld
System.out.println(stb3.insert(stb3.length(), "Mr"));//HelloWorldMr
//5.StringBuffer replace(int start,int end,String str):用str替换start到end-1处的所有字符
StringBuffer str=new StringBuffer("WDNMD");
str.replace(0, 2, "Sb");
System.out.println(str);//SbNMD
//6.StringBuffer reverse():反转
str.reverse();
System.out.println(str);//DMNbS
//7.void setCharAt(int index,char ch);替换index下标出的字符为ch
str.setCharAt(0, 'W');
System.out.println(str);//WMNbS
//System.out.println(str.setCharAt(0, 'b'));
1.5练习
package demo02;
public class Demo04 {
//练习1：写一个方法实现字符串转换：大小写转换 删除数字：只能使用字符串缓冲区
public static void main(String[] args) {
Demo04 d=new Demo04();
String s="15616515dawdAWEQ";
System.out.println(change(s));
}
public static String change(String s){
//字符串--->字符串缓冲区 通过构造方法
//字符串缓冲区-->字符串 toString方法
StringBuffer stb=new StringBuffer(s);
//遍历字符串缓冲区
for (int i = 0; i < stb.length(); i++) {
//获取当前字符
char c = stb.charAt(i);
//判断当前字符串的类型
if (Character.isUpperCase(c)) {
stb.setCharAt(i, Character.toLowerCase(c));
} else if(Character.isLowerCase(c)) {
stb.setCharAt(i, Character.toUpperCase(c));
}else if(Character.isDigit(c)){
stb.deleteCharAt(i);
i--;
}
}
return stb.toString();
}
}
package demo02;
public class Demo05 {
//写一个字符串的replace方法：void replace(StringBuffer stb,char old,char new);
public static void main(String[] args) {
StringBuffer stb = new StringBuffer("156156789789111");
replace(stb,'1', '2' );
System.out.println(stb);
}
static void replace(StringBuffer stb,char oldChar, char newChar){
while(true){
int index=stb.indexOf(oldChar+"");
if(index == -1){
return;
}
stb.setCharAt(index, newChar);
}
}
}
二、字符串常量池
==和equals的区别
==操作基本数据类型 判断的是值是否相同
int a=1,b=2; System.out.println(a==b);
//==操作引用数据类型 判断的是两个引用是否指向同一个对象
Object o1=new Object();Object o2=new Object(); System.out.println(o1==o2);
//equals是方法 只能操作引用数据类型
//equals是Object类的方法(判断两个引用是否指向同一个对象)：可以被子类重写
System.out.println(o1.equals(o2));
//创建字符串对象有两种方式：通过双引号+通过构造方法
String s1="123a",s2="123a";
String ss1=new String("123a");
String ss2=new String("123a");
System.out.println("s1==s2 "+(s1==s2));//true
System.out.println("ss1==ss2 "+(ss1==ss2));//false
System.out.println("s1==ss2 "+(s1==ss2));//false
System.out.println("s1.equals(s2) "+(s1.equals(s2)));//equals判断字符序列是否相同
System.out.println("ss1.equals(ss2) "+(ss1.equals(ss2)));
System.out.println("s1.equals(ss2) "+(s1.equals(ss2)));
//字符串常量池：当通过双引号创建字符串对象时 先判断此字符序列在字符串常量池中是否存在
// 如果存在直接使用 如果不存在 再创建
String s0=new String("1235");//创建了两个对象
//先通过双引号在 字符串常量池中创建一个"1235"
//再通过new 创建一个和"1235"相同序列的副本对象
三、Calendar
* 注意事项：
* 1：Calendar是抽象类，不能创建对象
* 通过静态方法static Calendar getInstance()获取一个子类对象
* 2：Calendar类与相关时间的所有参数都列出来，实现国际化
public static void main(String[] args) {
Calendar c = Calendar.getInstance();//获取的是Calendar的子类对象
DemoFu df=DemoFu.getInstance();
System.out.println(c);
//Calendar方法
//1.void add(int field,int amount):在指定时间参数，添加一个量
c.add(Calendar.YEAR, 1);//年+1
System.out.println(c);
//2.时间比较
//boolean after(Object when)
//boolean before(Object when)
//int compareTo(Calendar anotherCalendar)
Calendar c1=Calendar.getInstance();
DemoFu df1=DemoFu.getInstance();
c1.add(Calendar.YEAR, 2);
System.out.println(c.compareTo(c1));
//3.设置和获取时间参数
//int get(int field);
//void set(int field,int value);
c = Calendar.getInstance();
c.set(Calendar.YEAR, c.get(Calendar.YEAR)-1);//
System.out.println(myCalendarString(c));
//4.日历和日期之间转换
//void setTime(Date date);把当前日历对象设置为参数日期表示的时间
//Date getTime();获取当前日历对象相同时间对应的Date对象
java.util.Date d=new Date(0);//历元
c.setTime(d);
System.out.println(c);
c=Calendar.getInstance();
d=c.getTime();
System.out.println(d.toLocaleString());
//5.日历与毫秒值之间的转换
//void setTimills(long mills):把当前日历对象设置为参数毫秒值表示的时间
//long getTimeInMIllis();获取当前日历对象相同时间对应的毫秒值
Calendar c2 = Calendar.getInstance();
c2.setTimeInMillis(0);
System.out.println(myCalendarString(c2));
c2.getTimeInMillis();
System.out.println(myCalendarString(c2));
}
static String myCalendarString(Calendar c){
int year = c.get(Calendar.YEAR)+1;
int month = c.get(Calendar.MONTH)+1;
int day = c.get(Calendar.DAY_OF_MONTH);
int week = c.get(Calendar.DAY_OF_WEEK)+1;
int hour = c.get(Calendar.HOUR_OF_DAY);
int minute = c.get(Calendar.MINUTE);
int second = c.get(Calendar.SECOND);
String weeks = "日一二三四五六";
String s = year + "-" + month + "-" + day + "星期" +weeks.charAt(week) + " "+ hour + ":" + minute + ":" + second;
return s;
}
}
//Calendar类的设计思想
abstract class DemoFu{
static DemoFu getInstance(){
return new DemoZi();
}
void show(){}
abstract void hai();
}
class DemoZi extends DemoFu{
void hai(){}
}四、设计模式
概念：编程过程中，java大师总结的，在指定场景下可用的23中解决问题的方案(程序设计的套路)
按类型分类:
创建型模式:强调的是对象的创建
结构型模式:强调是结合方式
行为型模式:强调的是功能和算法
4.1单例模式
package demo02;
public class Demo08 {
public static void main(String[] args) {
//单例模式：一个类只能有一个对象
Singleton1 s11=Singleton1.getInstance();
Singleton1 s12=Singleton1.getInstance();
System.out.println(s11==s12);
}
}
//单例模式---饿汉式
class Singleton1{
//1.构造方法私有化
private Singleton1(){}
//2.定义一个成员变量，用于记录唯一的对象
private static Singleton1 s = new Singleton1();
//3.提供一个公共的方法类访问唯一的对象
public static Singleton1 getInstance(){
return s;
}
}
//单例模式---懒汉式
class Singleton2{
//1.构造方法私有化
private Singleton2(){}
//2.定义一个成员变量，用于记录唯一的对象
private static Singleton2 s;
//提供一个公共的方法类访问唯一的对象
public static Singleton2 getInstance(){
if(s == null){
s=new Singleton2();
}
return s;
}
}
4.2工厂模式
package demo02;
public class Demo {
//工厂模式：A类对象的创建交给B类的方法
//实力工厂模式:A类对象的创建，交给B类的实例方法
//静态工厂模式:A类对象的创建，交给B类的静态方法
public static void main(String[] args) {
DemoA d1=new FactoryInstance().getInstance();
DemoA d2=FactoryStatic.getInstance();
d1.haha();
d2.haha();
}
}
class DemoA{
void haha(){
System.out.println("a类的哈哈");
}
}
//实例工厂模式
class FactoryInstance{
public DemoA getInstance(){
return new DemoA();
}
}
//静态工厂模式
class FactoryStatic{
public static DemoA getInstance(){
return new DemoA();
}
}
五、集合
5.0集合框架的组成
* 集合框架:一堆与集合相关的接口、类的家族
* 集合:只能装引用数据类型数据的容器
* 数组:装指定个数个相同数据的容器
* 集合框架的组成:
* Collection:单列集合的顶层接口(增删改查每次操作一个数据)
* List(接口):有序列表
* ArrayList:
* Vactor:
* LinkedList:链接
*
* Set(接口):不重复列表
* HashSet:
* TreeSet:
*
* Map:双列集合的顶层接口(增删改查每次操作一对数据)
* HashSet:
* TreeMap:
* HashTable:
*
5.1集合与数组的区别
* 集合和数组的区别
*
* 相同之处:都是装多个数据的容器
* 都是引用数据类型的数据
*
* 不同之处:
* 1:集合的元素只能是引用数据类型
* 数组的元素既可以是引用数据类型，也可以是基本数据类型
* 2:集合中元素的类型可以不同
* 数组一旦创建，元素类型必须一致
* 3:集合中元素的个数可以更改
* 数组一旦创建，元素个数不能更改
* 4:集合中的元素没有默认值
* 数组中的元素有默认值
public static void main(String[] args) {
//Collection:单列集合的顶层接口
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
//1.int size():获取元素个数
//System.out.println(c1.size());
//2添加元素
//2.1 boolean add(Object e)
//2.2 boolean addAll(Collection c):把参数集合c中的所有元素添加到当前集合中
c1.add("123");c1.add(1);
System.out.println(c1);
System.out.println(c1.size());
//3.删除元素
//3.1 void clear():清空
//3.2 boolean remove(Object o);把当前集合中的第一个o元素删除
//c1.remove("123");
//System.out.println(c1);
//4.判断
//4.1 boolean contains(Object o):判断当前集合是否包含参数元素o
//4.2 boolean isEmpty():判断当前集合是否为空 size = 0;
System.out.println(c1.contains(1));//true
System.out.println(c1.isEmpty());//false
//5.转换
//5.1 Object[] toArray():获取当前集合对应的数组对象
System.out.println(c2.toArray()+"]");//[Ljava.lang.Object;@15db9742]
5.2遍历Collection的方式
/6.获取迭代器:封装了遍历集合的方式
//6.1 Iterator iterator()
// Iterator的方法:boolean hasNext()判断是否含有元素可以遍历
// Iterator的方法: E next() 获取一个元素
//遍历Collection方式1:由集合获取数组，通过遍历数组来遍历集合
Object [] arr = c1.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println("arr["+i+"]="+arr[i]);
}
//遍历Collection方式2:简洁for循环--foreach
for (Object object : arr) {
System.out.println("c1=="+c1);
if(object == "123"){
c1.remove(object);
}
}
//遍历Collection方式2:简洁for循环--foreach
for (Object object : arr) {
System.out.println("c1=="+c1);
if(object == "123"){
c1.remove(object);
}
}
for (Object object : arr) {//简洁for循环遍历数组
System.out.println("object=="+object);
}
//简洁for循环的优点:简洁
//缺点:1、无法获取下标
// 2、遍历时不能增删改
//遍历Collection方式3：通过迭代器
Iterator it=c1.iterator();
for (int i = 0; i < c1.size(); i++) {
System.out.println(i+"-----"+it.next());
}
while(it.hasNext()){//判断迭代器中是否还有元素可以遍历
Object o = it.next();//获取一个元素
System.out.println(o);
}
文章转载自代码钢琴家，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。
