String字符串的处理

作者: 王康健_0124 | 来源:发表于2018-07-20 10:51 被阅读0次

对String字符串的处理分成4类

字符串长度的处理

两个字符串之间的关系

字符串的解析

字符串的转换

1. 字符串长度的处理

判断一个字符串是否为空

① ==null 存不存在
② "".equals(String) 有没有内容

例如：

        //已经分配内存，但是没有存数据
        String s2="";
        //没有分配内存
        String s3=null;
        //已经分配内存，并且存了数据“hello"
        String s4="hello";

演示图：

String.length() 长度处理：获取当前字符串的长度

    public static void main(String[] args) {
    String string="2018年07月17日 '22时55分'";
    //定义一个String类型的字符串变量，数据中有数字、汉字、空格、符号
    //只要占了一个字符位置，都算在length()方法中
    
    int length=string.length();
    //获取长度，存到length变量中
    
    System.out.println(length);
    //打印长度
    }

演示图：

2. 两个字符串之间的关系

① 两个字符串之间的相加、拼接：+



    public static void main(String[] args) {
    String str1="好好学习，";
    String str2="天天向上!";
    String str3=str1+str2;
    String str4=str3+"说的就是我！";
    
    System.out.println("变量之间进行拼接："+str3);
    // 变量之间进行拼接
    
    System.out.println("变量和字符串进行拼接："+str4);
    //
    }

演示图：

② 判断两个字符串是否相等

equals(); ：是否相等，大小写敏感，返回值boolean类型



    public static void main(String[] args) {
        String str1 = "helloWord";
        String str2 = "HelloWord";
        boolean result1 = str1.equals(str2);
        // 判断str1和str2是否相等，因为大小写不一样，不符合条件，返回false

        boolean result2 = !str1.equals(str2);
        // 判断str1和str2是否不相等，因为判断结果不相等，符合条件，返回true

        boolean result3 = str2.equals("HelloWord");
        // 判断str2和HelloWord是否相等，因为它们一模一样，符合条件，返回true

        System.out.println("str1是否和str2相等：" + result1 + "\r\nstr1和str2是否不相等："
                + result2 + "\r\nstr2是否和HelloWord相等：" + result3);
    }

演示图：

equalsIgnoreCase(); ：是否相等，大小写不敏感，返回boolean类型



    public static void main(String[] args) {
        String str1 = "helloWord";
        String str2 = "HelloWord";
        boolean result1 = str1.equalsIgnoreCase(str2);
        //判断是否相等，忽略大小写
        
        boolean result2=str2.equalsIgnoreCase("Hello");
        //判断str2是否等于Hello

        System.out.println("str1是否和str2相等：" + result1 + "\r\nstr2和Hello是否相等："
                + result2 );
    }

演示图：

③ contains(); :包含

字符串1 是否包含字符串 2，返回boolean类型


    public static void main(String[] args) {
        String str1 = "好好学习，";
        String str2 = "学习";

        boolean result1 = str1.contains(str2);
        // 判断str1是否包含str2

        boolean result2 = str1.contains("NO");
        // 判断str1是否包含"NO"

        boolean result3 = str1.contentEquals("好好学习，");
        // 判断内容是否相等

        System.out.println("result1=" + result1 + "\r\nresult2=" + result2
                + "\r\nresult3=" + result3);
    }

演示图：

④ String2在String1中的位置

indexOf(); ：第一次出现的位置
lastIndexOf(); ：最后一次出现的位置


    public static void main(String[] args) {
        String str1 = "好好学习啦学习试试";
        String str2 = "学习";

        int result1 = str1.indexOf(str2);
        //// str2在str1中第一次出现的位置，编程语言中位子是以0开始的
        
        int result2 = str1.lastIndexOf(str2);
        // str2在str1中最后一次出现的位置，编程语言中位子是以0开始的

        System.out.println("str2在str1出现的位子是:" + result1
                + "\r\nstr2在str1最后出现的位子是: " + result2);
    }

演示图：

3. 字符串解析

split(分隔符);

拆分字符串（ArrayList中：单值）：把一段字符串按照一定的规律进行拆分，结果存到容器

public void strSplit(){
        //分隔符固定，内容长度不固定
        String str="好好学习|天天上上 太阳当空照|花儿对我笑";
        //把多个值同时用一个变量存起来，就得用到容器：单值（数组、arraylist、hashset），键值对（hashmap）
        String[] result=str.split("|");
        //变量容器内的所有内容，用for each
        for(String s:result){
            //遍历，打印出分割后的所有数据
            System.out.println(s);

        String param="ct=17&pn=0&tn=ikaslist&rn=10&fr=wwwt&word=简历%20英文";
        //先获得一串URL的请求正文
        
        String[] params=param.split("&");
        //按照&符号进行分割，获得多个键值对，存到容器中
        
        for(String s:params){
            String[] entry=s.split("=");
        //遍历出分割的字符串，进行二次分割，并把值存到一个变量中
            String key=entry[0];
            String value=entry[1];
        }
        }

分割、二次分割、值存HashMap数组、foreach遍历、iterator遍历

package com.guoyasoft.topic.string;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class TestJianShu {
    public static void main(String[] args) {
        // 前端界面传的金额、年龄等为字符串，后端要进行数字计算，必须转成对应类型的数字
        HashMap<String, String> ha = new HashMap<String, String>();
        String param = "ct=17&pn=0&tn=ikaslist&rn=10&fr=wwwt&word=简历%20英文";

        String[] params = param.split("&");
        // 按照&符号进行分割，获得多个键值对，存到容器中

        for (String s : params) {
            // 遍历出所有分割后的字符串
            String[] entry = s.split("=");

            // 二次分割，获得键值对,然后把分割后的数据存到HashMap数组中
            ha.put(entry[0], entry[1]);
        }
        System.out.println(ha.get("tn"));
        // 取存到HashMap中的数据，按key进行取值

        Set<Entry<String, String>> mapha = ha.entrySet();
        // 调用Map.entrySet()方法，把所有<K,V>键值对的集合，一对对的放入到一个set的数组集合中,
        // Set泛型：Entry<String, String>，由创建HashMap数组时定义的泛型类型

        Iterator<Entry<String, String>> itmap = mapha.iterator();
        // iterator迭代器模式:为遍历不同的容器结构提供一个统一的接口(多态迭代)
        // Iterator模式:使得我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。
        // 简单理解就是，数组调用iterator()方法，数组自身进行排序，可以使用.hasNext()和.next访问所有数组中数据

        // Iterator和foreach的区别:多态差别,因为foreach底层就是Iterator
        // Iterator是一个接口类型，他不关心集合或者数组的类型;
        // for和foreach都需要先知道集合的类型，甚至是集合内元素的类型;

        while (itmap.hasNext()) {
            // 调用Iterator接口类，它并不关系遍历的是什么类型的数组，直接.next()拿值
            // 这里把拿到的值重新存到一个对应类型的变量中,其实可以直接itmap.next().getKey();取值
            Map.Entry<String, String> item = itmap.next();
            String key = item.getKey();
            String value = item.getValue();
        }

        for (Entry<String, String> entry : mapha) {
            // 在做foreach遍历，必须先知道遍历的数组类型
            String key = entry.getKey();
            String value = entry.getValue();
        }

    }
}

substring();
截取字符串：从什么位置到什么位置(N位置到M位置之间，或者N位置到结束)


    public static void main(String[] args) {
        String s1 = "好好学习，天天向上，确认过眼神，遇上对的人";

        // 截取2位置开始，到结束
        String s2 = s1.substring(2);
        System.out.println("截取s1的第2个位置到末尾的字符串：" + s2);

        // 截取2位置开始，到6位置之前
        String s3 = s1.substring(2, 6);
        System.out.println("截取s1的第2位到第6位的字符串：" + s3);

        // 截取：substring可以和indexOf结合使用

        int index = s1.indexOf("，");
        // 确定开始到第一个"，"的字符串个数
        
        System.out.println(index);
        String s4 = s1.substring(0, index);
        //截取开始到index的字符串
        
        System.out.println(s4);
        s4 = s1.substring(index + 1);
        //截取"，"位置+1到结束的字符串
        
        System.out.println(s4);‘’

    }

4. 字符串转换

① 字符串与数字相互转换

数字转换成字符串：使用+拼接

    public static void main(String[] args) {
        int a = 128;
        String b = a + "";
        //int类型的变量a与""拼接，a的类型就改为了String类型
        System.out.println(b);
    }

字符串转数字
Integer.parseInt(字符串);
Long.parseLong(字符串);
Double.parseDouble(字符串)

    public static void main(String[] args) {
        String a = "128";
        int b;
        //定义String变量a，并初始化。;定义一个int变量b。
        
        b = Integer.parseInt(a);
        //把日期转换成int类型的数据存到变量b中
        System.out.println(b);
    }

② 字符串与日期相互转换

日期转字符串

创建时间展现格式：SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

获取时间

sdf.format(时间格式的变量);


    public static void main(String[] args) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        // 定义时间展现格式

        Calendar c = Calendar.getInstance();
        // 获取当前时区日历
        c.add(Calendar.DAY_OF_WEEK, 1);
        String strDate = sdf.format(c.getTime());
        // sdf格式下使用format方法，把获取的日期改成字符串类型格式
        System.out.println(strDate);

        c.add(Calendar.DAY_OF_MONTH, 1);
        //对获取的日期进行修改，当前日期加一天
        
        c.add(Calendar.DAY_OF_WEEK, 1);
         //对获取的日期进行修改，按星期增加
        
    }

字符串转日期

先要有个String类型的时间字符串

确定时间格式： SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

用SimpleDateFormat 下的parse()方法进行转换时间类型格式

        String str="2018-04-23 21:41:23";
        SimpleDateFormat sf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //字符串转时间
        Date date=sf.parse(str);
        System.out.println(date);
        //时间转字符串
        //当前日期-计算机元年，单位：毫秒
        //计算机元年：（1970-01-01 00:00:00），类似民国35年，贞观14年，万历15年
        long time1=date.getTime();
        long time2=new Date().getTime();
        System.out.println(time2-time1);

数字转换日期


    public static void main(String[] args) {
        long str = 603134410;
        // 当前日期-计算机元年，单位：毫秒

        Date date = new Date(str);
        // date.setTime(str);第二次赋值方式
        System.out.println(date);
        // 把str转换成时间格式,打印看一下结果

        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
        // 确定展现格式yyyy：年 MM：月 dd：日

        String StringDate = sf.format(date);
        // 时间转换字符串

        System.out.println(StringDate);
    }

String字符串的处理

对String字符串的处理分成4类

1. 字符串长度的处理

判断一个字符串是否为空

String.length() 长度处理：获取当前字符串的长度

2. 两个字符串之间的关系

① 两个字符串之间的相加、拼接：+

② 判断两个字符串是否相等

③ contains(); :包含

3. 字符串解析

4. 字符串转换

① 字符串与数字相互转换

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读