Java-API-1
程序员文章站
2022-04-29 18:57:48
...
String
public static void stringConstructorDemo() {
String s = new String(); //等效于String s = ""; 不等效String s = null;
byte[] arr = {97,66,67,68};
String s1 = new String(arr);
System.out.println("s1="+s1);
}
运行結果：
s1=aBCD
private static void stringConstructorDemo2() {
char[] arr = {'w','a','p','q','x'};
String s = new String(arr,1,3);
System.out.println("s="+s);
}
运行結果：
s=apq
1、都存储在字符串常量池中：
private static void stringDemo1() {
String s = "abc";//"abc"存储在字符串常量池中。
String s1 = "abc";
System.out.println(s==s1); //true
}
字符串常量池特点：字符池中没有就建立，池中有，直接用。
.
.
2、一个在堆内存，另一个在常量池中：
public static void stringDemo2() {
String s = "abc"; //创建一个字符串对象在常量池中。
String s1 = new String("abc"); //创建两个对象一个new一个字符串对象在堆内存中。
System.out.println(s==s1); //false
System.out.println(s.equals(s1)); //true
//string类中的equals复写Object中的equals建立了string类自己的判断字符串对象是否相同的依据。
//其实就是比较字符串内容。
// System.out.println("s="+s);
// System.out.println("s1="+s1);
}
对字符串的操作：
private static void stringMethodDemo_1() {
String s = "abcdae";
System.out.println("length:"+s.length()); //6
System.out.println("char:"+s.charAt(2)); //c//StringIndexOutOfBoundsException
System.out.println("index:"+s.indexOf('k')); //0//-1 我们可以根据-1，来判断该字符或者字符串是否存在。
System.out.println("lastIndex:"+s.lastIndexOf('a')); //4
System.out.println("substring:"+s.substring(2,4)); //cd
}
private static void stringMethodDemo_2() {
String s = "张三,李四,王五";
String[] arr = s.split(",");
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 张三
李四
王五
char[] chs = s.toCharArray();
for (int i = 0; i < chs.length; i++) {
System.out.println(chs[i]);
}
张
三
,
李
四
,
王
五
s = "ab你";
byte[] bytes = s.getBytes();
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);
}
97
98
-60
-29
System.out.println("Abc".toUpperCase());
ABC
String s1 = "java";
String s2 = s1.replace('j', 'z');
System.out.println(s1==s2);
//false
System.out.println("-"+" ab c ".trim()+"-");
-ab c-
}
private static void stringMethodDemo_3() {
String s = "abc";
System.out.println(s.equals("ABC".toLowerCase())); //true 变成小写字母进行对比
System.out.println(s.equalsIgnoreCase("ABC")); //true 忽略大小写对比长度和对应字符
System.out.println(s.contains("ac")); //false 包含按其顺序的字符返回true
String str = "ArrayDemo.java";
System.out.println(str.startsWith("Array")); //true 由什么开始
System.out.println(str.endsWith(".java")); //true 由什么结束
System.out.println(str.contains("Demo")); //true
}
private static void stringMethodDemo_4() {
System.out.println("abc".compareTo("abd")); //-1
}
String s1 = "abc"; //true
//new String("abc"); //false
String s2 = s1.intern();
System.out.println(s1==s2);
System.out.println("abc".concat("kk"));
System.out.println("abc"+"kk");
都是连接字符串
按照面向对象的思想对字符串进行功能分类。
"abcd"
1,获取：
1.1 获取字符串中字符的个数(长度).
int length();
1.2 根据位置获取字符。
char charAt(int index);
1.3 根据字符获取在字符串中的第一次出现的位置.
int indexOf(int ch)
int indexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
int indexOf(String str);
int indexOf(String str,int fromIndex);
根据字符串获取在字符串中的第一次出现的位置.
int lastIndexOf(int ch)
int lastIndexOf(int ch,int fromIndex):从指定位置进行ch的查找第一次出现位置
int lastIndexOf(String str);
int lastIndexOf(String str,int fromIndex);
1.4 获取字符串中一部分字符串。也叫子串.
String substring(int beginIndex, int endIndex)//包含begin 不包含end 。
String substring(int beginIndex);
2,转换。
2.1 将字符串变成字符串数组(字符串的切割)
String[] split(String regex):涉及到正则表达式.
2.2 将字符串变成字符数组。
char[] toCharArray();
2.3 将字符串变成字节数组。
byte[] getBytes();
2.4 将字符串中的字母转成大小写。
String toUpperCase():大写
String toLowerCase():小写
2.5 将字符串中的内容进行替换
String replace(char oldch,char newch);
String replace(String s1,String s2);
2.6 将字符串两端的空格去除。
String trim();
2.7 将字符串进行连接 。
String concat(string);
3,判断.
3.1 两个字符串内容是否相同？
boolean equals(Object obj);
boolean equalsIgnoreCase(string str);忽略大写比较字符串内容。
3.2 字符串中是否包含指定字符串？
boolean contains(string str);
3.3 字符串是否以指定字符串开头。是否以指定字符串结尾。
boolean startsWith(string);
boolean endsWith(string);
4，比较。
compareTo()
/*
* 1，给定一个字符串数组。按照字典顺序进行从小到大的排序。
* {"nba","abc","cba","zz","qq","haha"}
*
* 思路：
* 1,对数组排序。可以用选择，冒泡都行。
* 2,for嵌套和比较以及换位。
* 3,问题：以前排的是整数，比较用的比较运算符，可是现在是字符串对象。
* 字符串对象怎么比较呢？
* 对象中提供了用于字符串对象比较的功能。
*/
public class StringTest_1 {
public static void main(String[] args) {
String[] arr = { "nba", "abc", "cba", "zz", "qq", "haha" };
printArray(arr);
sortString(arr);
printArray(arr);
}
public static void sortString(String[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if(arr[i].compareTo(arr[j])>0)//字符串比较用compareTo方法
swap(arr,i,j);
}
}
}
private static void swap(String[] arr, int i, int j) {
String temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public static void printArray(String[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1)
System.out.print(arr[i] + ", ");
else
System.out.println(arr[i] + "]");
}
}
}
/*
* 2，一个子串在整串中出现的次数。
* "nbaernbatynbauinbaopnba"
* 思路：
* 1，要找的子串是否存在，如果存在获取其出现的位置。这个可以使用indexOf完成。
* 2，如果找到了，那么就记录出现的位置并在剩余的字符串中继续查找该子串，
* 而剩余字符串的起始位是出现位置+子串的长度.
* 3,以此类推，通过循环完成查找，如果找不到就是-1，并对 每次找到用计数器记录。
*/
public class StringTest_2 {
public static void main(String[] args) {
String str = "nbaernbatnbaynbauinbaopnba";
String key = "nba";
int count = getKeyStringCount_2(str,key);
System.out.println("count="+count);
}
public static int getKeyStringCount_2(String str, String key) {
int count = 0;
int index = 0;
while((index = str.indexOf(key,index))!=-1){
index = index + key.length();
count++;
}
return count;
}
/**
* 获取子串在整串中出现的次数。
* @param str
* @param key
* @return
*/
public static int getKeyStringCount(String str, String key) {
//1,定义计数器。
int count = 0;
//2，定义变量记录key出现的位置。
int index = 0;
while((index = str.indexOf(key))!=-1){
str = str.substring(index+key.length());
count++;
}
return count;
}
}
/*
* 3，两个字符串中最大相同的子串。
* "qwerabcdtyuiop"
* "xcabcdvbn"
*
* 思路：
* 1，既然取得是最大子串，先看短的那个字符串是否在长的那个字符串中。
* 如果存在，短的那个字符串就是最大子串。
* 2，如果不是呢，那么就将短的那个子串进行长度递减的方式去子串，去长串中判断是否存在。
* 如果存在就已找到，就不用在找了。
*/
public class StringTest_3 {
/**
* @param args
*/
public static void main(String[] args) {
String s1 = "qwerabcdtyuiop";
String s2 = "xcabcdvbn";
String s = getMaxSubstring(s2, s1);
System.out.println("s=" + s);
}
/**
* 获取最大子串
* @param s1
* @param s2
* @return
*/
public static String getMaxSubstring(String s1, String s2) {
String max = null,min = null;
max = (s1.length()>s2.length())?s1:s2;
min = max.equals(s1)?s2:s1;
System.out.println("max="+max);
System.out.println("min="+min);
for (int i = 0; i < min.length(); i++) {
for(int a = 0,b = min.length()-i; b != min.length()+1; a++,b++){
String sub = min.substring(a, b);
// System.out.println(sub);
if(max.contains(sub))
return sub;
}
}
return null;
}
}
/*
* 4，模拟一个trim功能一致的方法。去除字符串两端的空白
* 思路：
* 1，定义两个变量。
* 一个变量作为从头开始判断字符串空格的角标。不断++。
* 一个变量作为从尾开始判断字符串空格的角标。不断--。
* 2,判断到不是空格为止，取头尾之间的字符串即可。
*/
public class StringTest_4 {
public static void main(String[] args) {
String s = " ab c ";
s = myTrim(s);
System.out.println("-" + s + "-");
}
public static String myTrim(String s) {
int start = 0, end = s.length() - 1;
while (start <= end && s.charAt(start) == ' ') {
start++;
}
while (start <= end && s.charAt(end) == ' ') {
end--;
}
return s.substring(start, end + 1);
}
}
StringBuffer
StringBuffer:就是字符串缓冲区。
用于存储数据的容器。
特点：
1，长度的可变的。
2，可以存储不同类型数据。
3，最终要转成字符串进行使用。
4，可以对字符串进行修改。
既然是一个容器对象。应该具备什么功能呢？
1，添加：
StringBuffer append(data);
StringBuffer insert(index,data);
2，删除：
StringBuffer delete(start,end):包含头，不包含尾。
StringBuffer deleteCharAt(int index):删除指定位置的元素
3，查找：
char charAt(index);
int indexOf(string);
int lastIndexOf(string);
4，修改：
StringBuffer replace(start,end,string);
void setCharAt(index,char);
增删改查 C(create)U(update)R(read)D(delete)
public static void bufferMethodDemo(){
//创建缓冲区对象。
StringBuffer sb = new StringBuffer();
sb.append(4).append(false);//.append("haha");
sb.insert(1, "haha");
sb.append(true);
System.out.println(sb);
}
运行结果：
4hahafalsetrue
private static void bufferMethodDemo_1() {
StringBuffer sb = new StringBuffer("abce");
// sb.append("xixi");
sb.insert(0, "qq");
System.out.println(sb.toString());
}
运行结果：
qqabce
private static void bufferMethodDemo_2() {
StringBuffer sb = new StringBuffer("abce");
sb.delete(1, 3); //ae
//清空缓冲区。
sb.delete(0,sb.length());
sb = new StringBuffer();
// sb.replace(1, 3, "nba");
// sb.setCharAt(2, 'q');
// sb.setLength(10);
System.out.println(sb.reverse()); //反转字符串
}
StringBuilder
/*
* jdk1.5以后出现了功能和StringBuffer一模一样的对象。就是StringBuilder
*
* 不同的是：
* StringBuffer是线程同步的。通常用于多线程。
* StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。
*
* jdk升级：
* 1，简化书写。
* 2，提高效率。
* 3，增加安全性。
*/
public class StringBuilderTest {
public static void main(String[] args) {
StringBuilder s1 = new StringBuilder("hello");
StringBuilder s2 = new StringBuilder("java");
show(s1,s2);
System.out.println(s1+"......."+s2);
}
private static void show(StringBuilder s1, StringBuilder s2) {
s1.append(s2);
s1 = s2;
}
}
//hellojava.......java
包装类
/*
* 基本数据类型对象包装类。
* 为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
* 用于描述该对象的类就称为基本数据类型对象包装类。
*
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* char Character
* boolean Boolean
*
* 该包装对象主要用基本类型和字符串之间的转换。
*
* 基本类型--->字符串
* 1,基本类型数值+""
* 2,用String类中的静态方法valueOf(基本类型数值);
* 3,用Integer的静态方法valueOf(基本类型数值);
*
* 字符串--->基本类型
* 1,使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****
* int parseInt("intstring");
* long parseLong("longstring");
* boolean parseBoolean("booleanstring");
* 只有Character没有parse方法
* 2,如果字符串被Integer进行对象的封装。
* 可使用另一个非静态的方法，intValue();
* 将一个Integer对象转成基本数据类型值。
*
*
*/
// System.out.println(Integer.MAX_VALUE);
// System.out.println(Integer.toBinaryString(-6));
// int num = 4;
// Integer i = new Integer(5);
// int x = Integer.parseInt("123");
// System.out.println(Integer.parseInt("123")+1);
// Integer i = new Integer("123");
// System.out.println(i.intValue());
/*
* 整数具备不同的进制体现。
*
* 十进制-->其他进制。
* toBinaryString
* toOctalString
* toHexString
*
* 其他进制-->十进制。
* parseInt("string",radix)
*/
// 十进制-->其他进制。
System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.toOctalString(60));
System.out.println(Integer.toHexString(60));
// System.out.println(Integer.toString(60,16));
// 其他进制-->十进制。
// System.out.println(Integer.parseInt("3c",16));
Integer a = new Integer("89");
Integer b = new Integer(300);
System.out.println(a==b);
System.out.println(a.equals(b));
// System.out.println(3>3);
System.out.println(a.compareTo(b));
public class WrapperDemo2 {
public static void main(String[] args) {
int num = 4;
num = num + 5;
Integer i = 4; //i = new Integer(4);自动装箱 简化书写。
i = i + 6;// i = new Integer(i.intValue() + 6); //i.intValue() 自动拆箱
// show(55); //多态
Integer a = new Integer(128);
Integer b = new Integer(128);
System.out.println(a==b); //false
System.out.println(a.equals(b)); //true
Integer x = 127; //jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间。
Integer y = 127;
System.out.println(x==y); //true
System.out.println(x.equals(y)); //true
}
public static void show(Object a){ //Object a = new Integer(55);
System.out.println("a="+a);
}
}
import java.util.Arrays;
/*
* 对一个字符串中的数值进行从小到大的排序。
* "20 78 9 -7 88 36 29"
*
* 思路：
* 1，排序，我很熟。可是我只熟int。
* 2，如何获取到这个字符串中的这些需要排序的数值？
* 发现这个字符串中其实都是空格来对数值进行分隔的。
* 所以就想到用字符串对象的切割方法将大串变成多个小串。
* 3，数值最终变成小字符串，怎么变成一个int数呢？
* 字符串-->基本类型 可以使用包装类。
*/
public class WrapperTest {
private static final String SPACE_SEPARATOR = " ";
/**
* @param args
*/
public static void main(String[] args) {
String numStr = "20 78 9 -7 88 36 29";
System.out.println(numStr);
numStr = sortStringNumber(numStr);
System.out.println(numStr);
}
/**
*
* @param numStr
* @return
*/
public static String sortStringNumber(String numStr) {
//1,将字符串变成字符串数组。
String[] str_arr = stringToArray(numStr);
//2,将字符串数组变成int数组。
int[] num_arr = toIntArray(str_arr);
//3,对int数组排序。
mySortArray(num_arr);
//4,将排序后的int数组变成字符串。
String temp = arrayToString(num_arr);
return temp;
}
public static String arrayToString(int[] num_arr) {
StringBuilder sb = new StringBuilder();
for(int x = 0; x<num_arr.length; x++){
if(x!=num_arr.length-1)
sb.append(num_arr[x]+SPACE_SEPARATOR);
else
sb.append(num_arr[x]);
}
return sb.toString();
}
public static void mySortArray(int[] num_arr) {
Arrays.sort(num_arr);
}
public static int[] toIntArray(String[] str_arr) {
int[] arr = new int[str_arr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(str_arr[i]);
}
return arr;
}
/**
* @param numStr
*/
public static String[] stringToArray(String numStr) {
String[] str_arr = numStr.split(SPACE_SEPARATOR);
return str_arr;
}
}
集合类
Collection接口
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
/**
* @param args
*/
public static void main(String[] args) {
Collection coll = new ArrayList();
// show(coll);
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1,c2);
}
public static void show(Collection c1,Collection c2){
//给c1添加元素。
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
//给c2添加元素。
c2.add("abc1");
c2.add("abc2");
c2.add("abc3");
c2.add("abc4");
c2.add("abc5");
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
//演示addAll
// c1.addAll(c2);//将c2中的元素添加到c1中。
//演示removeAll
// boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
// System.out.println("removeAll:"+b);
//演示containsAll
// boolean b = c1.containsAll(c2);
// System.out.println("containsAll:"+b);
//演示retainAll
boolean b = c1.retainAll(c2);//取交集，保留和指定的集合相同的元素，而删除不同的元素。
//和removeAll功能相反 。
System.out.println("retainAll:"+b);
System.out.println("c1:"+c1);
}
public static void show(Collection coll){
//1,添加元素。add.
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);
//2，删除元素。remove
// coll.remove("abc2"); //会改变集合的长度
//清空集合.
// coll.clear();
System.out.println(coll.contains("abc3")); //o==null ? e==null : o.equals(e)
System.out.println(coll);
}
}
上一篇： 一直显示自己的排名列表
下一篇： JWT所用到的依赖
推荐阅读