目录

一、三元运算符的使用

                 二、字符串的拼接

三、集合整理

四、泛型的使用

五、Map的使用

六、String和Stringbuffer的用法


一、三元运算符的使用

//三元运算符的使用
int scord = 80;
String type = scord > 60 ? "及格" : "不及格";
System.out.println(type); //及格
System.out.println( scord< 90 ? "不优秀" : "优秀");//不优秀

二、字符串的拼接

append() :拼接
reverse() :反转
toString(); 转成字符串
//字符串的拼接
StringBuilder sb1= new StringBuilder("a12");
sb1.append("a12");//a12a12
​
StringBuilder sb2 = sb1.reverse();//21a21a ,反转
​
System.out.println(sb2);
String s = sb2.toString();//转成字符串
​
List<String> stringList = new ArrayList<>();
StringBuilder stringBuilder = new StringBuilder();
stringList.add("upload/26f64955bbf3084b160719332db2e3a31639382877755Diary.pn");
stringList.add("upload/UserImageServer/G18190403/Diary/1625640720943Diary.png");
for (int i = 0; i < stringList.size(); i++) {
  stringBuilder.append(stringList.get(i)).append("|"); //拼接字符串
}
System.out.println(stringBuilder);

三、集合整理:

List接口常用方法:

List接口常用方法:
​
1、add(Object element): 向列表的尾部添加指定的元素。
​
2、size(): 返回列表中的元素个数。
​
3、get(int index): 返回列表中指定位置的元素,index从0开始。
​
4、add(int index, Object element): 在列表的指定位置插入指定元素。
​
5、set(int i, Object element): 将索引i位置元素替换为元素element并返回被替换的元素。
​
6、clear(): 从列表中移除所有元素。
​
7、isEmpty(): 判断列表是否包含元素,不包含元素则返回 true,否则返回false。
​
8、contains(Object o): 如果列表包含指定的元素,则返回 true。
​
9、remove(int index): 移除列表中指定位置的元素,并返回被删元素。
​
10、remove(Object o): 移除集合中第一次出现的指定元素,移除成功返回true,否则返回false。
​
11、iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。

四种遍历方式

 //第一种迭代器
Iterator<String> iterator = arrayList.iterator();
while(iterator.hasNext()){
    System.out.println(iterator.next());
}
 //转换成数组遍历
 String[] array = list.toArray(new String[0]);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
​
        }
 //foreach遍历
for(String st : arrayList){
    System.out.println(st);
}
 //for遍历
for (int i =0; i<arrayList.size();i++){
    System.out.println(arrayList.get(i));
}

出现的错误(迭代器使用不能增加,删除数据)

//迭代器使用不能增加,删除数据

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("不好好学习吗·1");
arrayList.add("不能");
Iterator<String> iterator = arrayList.iterator();
while(iterator.hasNext()){
    String s =iterator.next();
    if("不能".equals(s)){
        arrayList.remove(s);
    }
​
    System.out.println(iterator.next());
}

并发修改异常

Exception in thread "main" java.util.ConcurrentModificationException

修改方式

ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("好好的·");
arrayList.add("不好好学习吗·1");
arrayList.add("不能");
ArrayList<String> arrayList1 = new ArrayList<>();
Iterator<String> iterator = arrayList.iterator();
while(iterator.hasNext()){
    String s2 =iterator.next();
    if("不能".equals(s2)){
        arrayList1.add(s2);
    }
​
    System.out.println(s2);
}
arrayList.removeAll(arrayList1);

ArrayList和LinkList的区别

  1、ArrayList是Array(动态数组)的数据结构,LinkedList是Link(链表)的数据结构。
  2、   ArrayList: 查找快 ,增删慢
        LinkList: 增删快 , 查找慢

HashSet的使用

一、特点

  1. HashSet不能存储重复元素;

  2. HashSet不确保插入顺序;

  3. HashSet是非线程安全的。

二、常用方法

boolean  add() : 添加数据
boolean  remove(): 删除数据
boolean  contains(): 判断元素是否存在
HashSet<String> set = new HashSet<>();
set.add("不好好学习嘞");
set.add("如果不学习,还能干嘛嘞");
set.add("我是小王呀");
String s2 = set.contains("我是小王")? "不错" : "你不是的呀";       //你不是呀

三、遍历方式(三种遍历)

 1、转换成数组遍历
 2、迭代器遍历
 3、foreach遍历
  //转换成数组遍历
String[] arr = set.toArray(new String[0]);
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

补充: “==” 和equals的使用:

“==”比较两个变量本身的值,即两个对象在内存中的首地址。

“equals()”比较字符串中所包含的内容是否相同

 String a1 = new String("abd");
        String a2 = new String("abd");
​
        String a4 = a1 == a2 ? "为真" : "为假";       //为假
        String a5 = a1.equals(a2) ? "为真" : "为假";  //为真

四、泛型的使用

理解:

泛型其实就是一个标签,用来限制集合中数据类型,方便数据的管理;

Collection, List, ArrayList 这个就是类型参数,即泛型。

1、泛型类与接口

定义泛型类与接口就是在类名或接口名后面加上<>就可以了

public class GenericTest<E> {
}    
public interface GenericInterfaceTest<E> {
}

子类(实现类)继承自父类(实现接口)的时候,如果父类或接口指定了泛型的数据类型,那么子类与实现类就不用再指定泛型类型了

public class SubGenericTest extends GenericTest<Integer> implements GenericInterfaceTest<Integer> {
}

子类(实现类)继承自父类(实现接口)的时候,如果父类或接口没有指定了泛型的数据类型,那么子类与实现类也必须需要定义为泛型类

public class SubGenericTest2<E> extends GenericTest<E> implements GenericInterfaceTest<E> {
​
}

2、泛型方法

 // 泛型方法
    public static<T> void b(T t){
        System.out.println("b方法是泛型方法");
    }

*3、泛型受限*

*泛型受限就是规定使用通配符的泛型数据类型的范围 有上限与下限两种限制方式 上限规定后包括了指定的数据类型 下行规定后不包括指定的数据类型*

public class Test {
    // 这是main方法,实现程序主要逻辑
    public static void main(String[] args) {
        List<Object> a = new ArrayList<>();
        List<Person> b = new ArrayList<>();
        List<Student> c = new ArrayList<>();

    // 泛型的上限
    List<? extends Person> list1 = new ArrayList<>();
    /*
    List<? extends Person> 相当于泛型里面的数据类型继承自Person,通配符里面的数据类型可以是Person以及Person的所有子类
     */
​
    // 泛型的下限
    List<? super Student> list2 = new ArrayList<>();
    /*
    List<? super Student>相当于泛型里面的数据类型是所有Student的直接父类与间接父类
     */
}
​

五、Map的使用

1、特点

HashMap集合的特点
   1、底层数据结构是哈希表
   2、存储元素的顺序和遍历获取出来的顺序不一致
   3、key不会重复

2、常用方法

put(k key, V value) //添加元素
get(object key) //获取元素 ,根据key获取value
remove(object key)//根据key删除value值
boolean containskey(object object) //判断key是否存在
int size( ) //集合中的键值对,对数
void clear() //清空所有的键值对

3、遍历方式

 HashMap<String,Integer> map = new HashMap<>();
        map.put("a",23);
        map.put("张三",12);
        map.put("好好学习呀",24);
   
//1、entrySet 遍历
  Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println(entry.getKey()+"===="+entry.getValue());
            
             /**
         *  2、使用keySet遍历
         *  map集合的keySet获取Set集合,存放所有的key
         *  遍历Set集合获取key对象, 通过key获取对应的value
         */
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key+"====="+map.get(key));
        }
​

六、String和Stringbuffer的用法

1、String常用方法

valueOf(基础数据类型 b) 
       //   将基础类型数据的文本转换为字符串
​
substring(int beginIndex) 
       // 切割原字符串,返回一个新的字符串,
       //     beginIndex:表示从下标为几的地方开始切割
    
replace(char oldChar, char newChar) 
       //   返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
    
isEmpty() 
        //  当且仅当 length() 为 0 时返回 true。
​
equals(Object anObject) 
        // 将此字符串与指定的对象比较。
    
split(String regex) 
        // 根据给定正则表达式的匹配拆分此字符串。
    

字符串的截取

序号 方法名称 类型 描述
1 substring(int beginIndex) 普通 从指定索引位置(包含该位置的字符)截取至末尾
2 substring(int beginIndex, int endIndex) 普通 截取指定索引范围内的字符串(包含起始索引,不包含end索引)

字符串的拆分

序号 方法名称 类型 描述
1 split(String regex) 普通 全部拆分
2 split(String regex,int limit) 普通 部分拆分

二、在字符串中查询指定子字符串的位置

charAt(int index) 
         // 获取指定索引处的 char 值。没有则为null
​
indexOf(string) 
         // 返回指定字符在此字符串中第一次出现处的索引。没有则为0
    
lastIndexOf(int ch) 
          //返回指定字符在此字符串中最后一次出现处的索引。
​
lastIndexOf(int ch, int fromIndex) 
          //返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
    
contains(CharSequence s) 
          //判断字符串是否包含指定的 char 值,有则返回 true。
​

StringBuilder类常用方法

StringBuilder  //上的主要操作是 append 和 insert 方法,
append  //方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的索引下添加字符。 
​
​
StringBuilder(String str) 
         // 构造一个字符串缓冲区,并将其内容初始化为指定的字符串内容。
​
append(基础类型数据 b) 
         // 将 基础类型的字符串表示形式追加到序列后面。
​
charAt(int index) 
         // 返回此序列中指定索引处的 char 值。
​
delete(int start, int end) 
        //  移除此序列的子字符串中的字符。
​
deleteCharAt(int index) 
         // 移除此序列指定位置的 char。
​
insert(int offset, 基础类型数据 b) 
         // 将 基础类型参数的字符串表示形式插入指定位置中。
​
toString() 
          //返回此序列中数据的字符串表示形式。
​

七、时间处理、

  //localDateTime转成Stirng类型
LocalDateTime dateTime = LocalDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
   第一次发布文章,如有错误,请指正,谢谢