精华内容
下载资源
问答
  •  无论是哪种编程语言,对字符串的操作都是必不可少的。JAVA中为我们提供了三个操作字符串的类,分别是String、StringBuffer、StringBuilder,下面我们将会详细进行介绍。  String、StringBuffer、StringB...

    1.概述

      刚看了一下,我截图的文档字太小了好像有点看不清,请放大浏览器页面观看(Ctrl + 鼠标滚轮)或者到  官方API文档查看

      无论是哪种编程语言,对字符串的操作都是必不可少的。JAVA中为我们提供了三个操作字符串的类,分别是String、StringBuffer、StringBuilder,下面我们将会详细进行介绍。

      String、StringBuffer、StringBuilder类都是在java.lang包中定义的。所有的应用程序都可以使用他们。所有的这些类都被声明为final,这就意味着这些类不能有子类。这使得对于通用的字符串操作

      可以采用特定的优化用来提高性能,并且这三个类都实现了CharSequeue接口。

      提示:所谓的String类型对象中的字符串不可改变是指创建了String实例后不能修改实例的值。但是在任何时候都可以修改String引用变量,使其指向其他String对象。

    2. String类

      2.1 构造函数:

          String类有众多的构造函数。一般我们使用一个传入一个字符串的构造函数。当然,如果我们想创建一个空字符串,可以使用默认的构造函数。

          其它构造函数列表如下:

      2.2 其他方法

          这里也不再赘述,要学会查询文档! 这里给出常用函数列表:

     

      2.3 注意事项

          1. String 字符串是支持+号连接的,并且在编译时,String会将+号去掉,用来简化拼接方式。

          2. 当字符串与数字进行连接的时候,若字符串在数字之前,则将数字转换成字符串,然后进行连接;若数字在前,则先对数字进行计算,将计算的结果与字符串进行拼接。(仅限+号)

     1 public class TestString {
     2 
     3     public static void main(String[] args) {
     4         String s1 = "abc"+ 5+2;  //直接拼接
     5         String s2 = 5+2+"abc"; //先计算后拼接
     6         String s3 = "abc"+5*2;//对于出去+号之外的都要先计算再拼接
     7         System.out.println(s1); //abc52
     8         System.out.println(s2); //7abc
     9         System.out.println(s3); //abc10
    10     }
    11 
    12 }

          3.equals 与 == 的区别:equals 是用来比较两个字符串的值是否相等(只要值相等即可,并不要求引用相同),而==是比较两个字符串的引用地址是否是同一个地址(尽管值相等,但是引用地址不一定相等)

    public class TestString {
    
        public static void main(String[] args) {
            String s1 = new String("xiaobai");
            String s2 = new String("xiaobai");
            System.out.println(s1.equals(s2)); //true  值相等
            System.out.println(s1==s2); //false //不是相同的引用    
        }
    
    }

          4.字符串的单一性(常量保存):字符串是不可变对象,而且是存储在常量区的,意思就是说,如果常量区中有某一个字符串,当我们再次声明它时,jvm并不会为我们再创建一个新的字符串,而是将已经存在的字符串的引用返回。

    public class TestString {
        public static void main(String[] args) {
            String s1 = "xiaobai";
            String s2 = "xiaobai";
            System.out.println(s1.equals(s2)); //true  值相等
            System.out.println(s1==s2); //true 常量单一    
        }
    }

    3.StringBuffer类

      3.1 概述

          我们知道,String类对象一旦确定就不能再修改,因为String类中的字符存储数组是final的。java为我们提供了一个可以更改的字符串操作类:StringBuffer。

      3.2 构造函数

          同理,这里直接给出构造函数:

      3.3 其他方法

      3.4 注意事项

          1.StringBuffer 不支持直接字面量赋值(也就是说不能直接把String对象引用赋值给StringBuffer),必须使用new 的形式。

    public class TestString {
        public static void main(String[] args) {
            StringBuffer s1 = "xiaobai"; //不合法 
            StringBuffer sb = new StringBuffer("ssss"); //正确
            
        }
    }

          2. StringBuffer 中的append方法可以进行链式调用,并且返回结果是最后一次链式调用的结果

    public class TestString {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer("xiao")
                    .append("bai").append("ni").append("hao");
            System.out.println(sb); //xiaobainihao
        }
    }

          3.StringBuffer是线程不安全的。

    4.StringBuilder类

      4.1 概述

          我们上面有提到,StringBuffer不是同步的,也就是说是线程不安全的。StringBuffer的优势是在于得到更高的性能。若我们同时有多个线程修改这个字符串怎么保证线程安全?

          当然,我们可以选择加锁同步。不过java已经为我们提供了一个类——StringBuilder  该类与StringBuffer基本相同,只不过他是线程安全的。

      4.2 构造方法

          

      4.3 其它常用方法

            与StringBuffer 基本相同,这里不再进行展示。

      4.4 注意事项

            这里也没什么可说的,等想到了再回来补充。

    5.String、StringBuffer、StringBuilder 比较

        这三个类的比较无非是效率(运行速度/内存占用)和线程安全上,

      首先我们来看一下速度:

        下面这段代码分别是创建和拼接一万个次的执行时间: 可以看出 执行时间效率 StringBuilder > StringBuffer > String 

        造成这种情况的原因也很简单,因为String 是单一实例(final)每次都要创建新对象并修改引用,所以最慢。

        而StringBuffer和StringBuilder的时间要比String短得多,原因也很简单,他只是在原有的字符串数组做添加操作,并不需要生成新对象和修改引用。

        StringBuilder比StringBuffer快的原因是StringBuffer实现了线程安全(synchronized),每次操作要获得锁,导致费时较长(但是要比String快的多)。

        

     1 public class TestString {
     2     public static void main(String[] args) {
     3         System.gc();
     4         long stringStart = System.currentTimeMillis();
     5         String s1 = new String();
     6         for(int i=0;i<100000;i++) {
     7             s1 =s1 + i;
     8         }
     9         long stringEnd = System.currentTimeMillis();
    10         System.out.println("10w String instance coast: "+(stringEnd-stringStart)+" ms");
    11     
    12         long stringBufferStart = System.currentTimeMillis();
    13         StringBuffer s2 = new StringBuffer();
    14         for(int i=0;i<100000;i++) {
    15             s2 = s2.append(i);
    16         }
    17         long stringBufferEnd = System.currentTimeMillis();
    18         System.out.println("10w StringBuffer instance coast: "+(stringBufferEnd-stringBufferStart)+" ms");
    19     
    20         long stringBuilderStart = System.currentTimeMillis();
    21         StringBuilder s3 = new StringBuilder();
    22         for(int i=0;i<100000;i++) {
    23             s3 = s3.append(i);
    24         }
    25         long stringBuilderEnd = System.currentTimeMillis();
    26         System.out.println("10w StringBuilder instance coast: "+(stringBuilderEnd-stringBuilderStart)+" ms");
    27         System.gc();
    28     }
    29 }

     

       然后再来看一下线程安全:

          由于String不支持修改,所以也就没有线程是否安全的说法(如果非要说有,那就是创建新对象时修改原来的引用地址为新地址,那一定是线程不安全的)。

          我们通过多线程程序测试:

          我分别在StringBuffer 和 StringBuilder 中循环了1000 次 ,每次拼接一个字母A ,同时开启三条线程进行这个操作。

          可以知道,如果线程安全 我们将会得到一个  3 * 1000 = 3000 长度的结果(一条线程拼接1000个 三条刚好3000个),通过结果我们可以看出,StringBuffer 是线程安全的,而SrtingBuilder的结果不足3000 说明发生了线程

          不安全的操作。(最直接的办法还是去jdk源码看一下,StringBuffer基本上每一个方法都有synchronized修饰)。

     

     1 public class TestString {
     2     public static void main(String[] args) throws InterruptedException {
     3         /**
     4          * @author xiaobai
     5          * 测试StringBuffer与StringBuilder的线程安全性 
     6          * 实现两个自己的线程类
     7          * 分别创建三条线程 并发执行
     8          * 等待线程全部执行完,统计结果 比较  
     9          * 
    10          * 若线程安全  应该是  3 * 1000 = 3000 
    11          */
    12         Thread t1 =  new Thread(new MyStringBufferTest());
    13         Thread t2 =  new Thread(new MyStringBufferTest());
    14         Thread t3 =  new Thread(new MyStringBufferTest());
    15         
    16         Thread t4 =  new Thread(new MyStringBuilderTest());
    17         Thread t5 =  new Thread(new MyStringBuilderTest());
    18         Thread t6 =  new Thread(new MyStringBuilderTest());
    19         
    20         t1.start(); t2.start(); t3.start(); t4.start(); t5.start(); t6.start();
    21         
    22         while(Thread.activeCount()>1); //等待线程执行完
    23         
    24         System.out.println("StringBuilder : "+MyStringBuilderTest.sbd.length());  //不一定是多少
    25         System.out.println("StringBuffer : "+MyStringBufferTest.sbf.length()); // 一定是 3000 
    26         
    27     }
    28 }
    29 
    30 class MyStringBufferTest implements Runnable{
    31     static StringBuffer sbf = new StringBuffer();
    32     /**
    33      * 进行1000 次拼接字符操作  
    34      * 中途sleep 10ms 使效果更好
    35      */
    36     @Override
    37     public void run() {
    38         for(int i=0;i<1000;i++) {
    39             sbf.append("A");
    40             try {
    41                 Thread.sleep(10);
    42             } catch (InterruptedException e) {
    43                 // TODO Auto-generated catch block
    44                 e.printStackTrace();
    45             }
    46         }
    47     }
    48 }
    49 
    50 class MyStringBuilderTest implements Runnable{
    51     static StringBuilder sbd = new StringBuilder();
    52     /**
    53      * 进行1000 次拼接字符操作  
    54      * 中途sleep 10ms 使效果更好
    55      */
    56     @Override
    57     public void run() {
    58         for(int i=0;i<1000;i++) {
    59             sbd.append("A");
    60             try {
    61                 Thread.sleep(10);
    62             } catch (InterruptedException e) {
    63                 // TODO Auto-generated catch block
    64                 e.printStackTrace();
    65             }
    66         }
    67     }
    68 }

     

     

    结果:

     

       比较结论:

          效率上  : 由快到慢  StringBuilder > StringBuffer > String 

          线程安全性: String  不安全   StringBuilder 不安全  StringBuffer 安全

           

     

        

          

    转载于:https://www.cnblogs.com/xiaobai1202/p/10896325.html

    展开全文
  • Java中的String类是字符串操作类,提供了多种方法对字符串进行操作,以下对String类的常用方法进行总结: String类的常用方法列表 图示: 图示2:截图一 String类简介 String类位于Java的lang包下,在使用时不需要...

    Java中的String类是字符串操作类,提供了多种方法对字符串进行操作,以下对String类的常用方法进行总结:

    String类的常用方法列表

    图示:
    在这里插入图片描述
    图示2:截图一
    在这里插入图片描述

    String类简介

    String类位于Java的lang包下,在使用时不需要通过import引入,java使用String类创建一个字符串变量,字符串变量属于对象。java把String类声明的final类,对象创建后不可修改,由0或多个字符组成,包含在一对双引号之间。

    String类创建对象

    用String类创建对象通常有两种形式:

    1. String str = " 输入字符串";

    2. String str1 = new String(“输入字符串”);

    方法1通过字面量直接给字符串进行赋值,在栈中创建字符串str时,会先在字符串常量池中检查是否已有该字符串,如果没有则创建并存入字符串常量池中,如果已存在则直接从常量池中获取。

    方法2创建的字符串,不管内存有没有为“chengjunyu”字符串分配内存,都会在内存中重新分配一个内存区域存放“chengjunyu”,然后用str1指向它,相当于内存中有两个“chengjunyu”,只是存放的地址不一样。

    String类的构造方法

    1. public String();

    String类的无参构造方法,用来创建空字符串的String类;

    案例:String str = new String();

    1. public String(String value);

    用已知的字符串value值来创建一个字符串对象;

    案例:String str1 = new String(“aaa”);

    1. public String(char[] value)

    用字符数组value创建一个String对象。

    案例:char[] value = {“ab”,“cd”,“efg”};

           String str1 = new String(value);       (等同于new String("abcdefg"));
    
    1. public String(char[] value, int startIndex, int numChars)

    用字符数组chars的startIndex开始的numChars个字符创建一个String对象。

    案例:char[] value = {“ab”,“cd”,“ef”,“g”};

          String str2 = new String(value,1,2);     (等同于new string("cdef"));
    
    1. public String(byte[] values)

    用byte的数组value值来创建字符串对象。

    案例:byte[] values = new byte[]{“a”,“b”,“c”,“d”,“e”};

           String str3 = new String(values);      (等同于new String("abcde"))
    

    String类的常用方法

    在这里插入图片描述

    在这里插入图片描述
    1、获取字符串长度:

    str.length();

    2、获取字符在字符传中出现的位置:

    str.indexOf(String str);

    从头开始查找str在字符串中第一次出现的位置;

    str.indexOf(String str,int fromIndex);

    从下标fromIndex处开始开始查找str在字符串中第一次出现的位置;

    str.lastIndexOf(String str);

    从尾部开始查找str在字符串中最后一次出现的位置;

    str.lastIndexOf(String str,int fromIndex);

    从下标fromIndex处开始开始查找str在字符串中最后一次出现的位置;

    3、获取字符串中某一个位置的字符:

    str.charAt(int index);

    查找字符串中下标为index位置出现的字符串

    4、截取字符串:

    str.substring(fromIndex,endIndex);

    从fromIndex处开始截取到endIndex处结束,不包含下标为endIndex的字符;

    str.substring(fromIndex);

    从fromIndex处开始截取到最后;

    5、验证字符串开始或结束的字符:

    开始位置字符:str.startWith(String str1),返回Boolean值;

    结束位置字符:str.endWith(String str1),返回Boolean值;

    6、字符串的比较:

    int num = str.compareTo(String str1);

    对字符串内容按字典顺序进行大小比较,通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数,反之返回负整数,相等返回0。

    int num = str.compareToIgnore(String str1);

    和compareTo()方法类似,忽略大小写。

    boolean b = str.equals(Object obj);

    比较当前字符串和参数字符串,在两个字符串相等的时候返回true,否则返回false。

    boolean b = str.equalsIgnoreCase(Object obj);

    和equals方法类似,忽略大小写。

    7、字符串连接:

    str2 = str.concat(String str1);

    用concat连接两个字符城成为一个新的字符串。

    8、字符串中字符的大小写转换:

    小写转大写:str.toUpperCase();

    大写转小写:str.toLowerCase();

    9、字符串中字符的替换:

    str.replace(oldStr,newStr);

    用新的字符代替就得字符。

    10、字符串中清除空格:

    str.trim();

    清除字符串str两侧的空字符串。

    11、字符传中分割字符串为数组:

    str.split(String str1);

    用str1将字符串str分割成数组。

    public class method {
        public static void method1() {
            String str1 = "2020年2月9日" + "abcDEF";
            //1.获取字符串的长度
            int len = str1.length();
            System.out.println("1.获取字符串的长度" + len);
            int num1 = str1.indexOf("年");//从头开始查找“年”在字符串中第一次出现的位置
            int num2 = str1.indexOf("年", 2);//从下标2开始查找“年”在字符串中第一次出现的位置
            int num3 = str1.lastIndexOf("月");//从头开始查找 “月”在字符串中最后一次出现的位置
            int num4 = str1.lastIndexOf("2", 4);//从下标4处开始查找 “月”在字符串中最后一次出现的位置
            System.out.println("2.获取字符在字符串中出现的位置\n" + num1 + "\n" + num2 + "\n" + num3 + "\n" + num4);
            char num5 = str1.charAt(8);
            System.out.println("3.获取字符串中某一位置的字符\n" + num5);
            String num6 = str1.substring(5);
            String num7 = str1.substring(0, 5);
            System.out.println("4.截取字符串\n" + num6 + "\n" + num7);
            boolean num8 = str1.startsWith("2");
            boolean num9 = str1.endsWith("日");
            System.out.println("5.验证字符串开始或结束的字符\n" + num8 + "\n" + num9);
        }
    
        public static void method2() {
            String str1 = "2020年2月9日" + "abcDEF";
            String str2 = new String("2018年12月15日" + "ABCdef");
            int num10 = str1.compareTo(str2);
            int num11 = str1.compareToIgnoreCase(str2);
            boolean num12 = str1.equals(str2);
            boolean num13 = str1.equalsIgnoreCase(str2);
            System.out.println("6.字符串的比较\n" + num10 + "\n" + num11 + "\n" + num12 + "\n" + num13);
            String num14 = str2.concat(str1);
            System.out.println("7.字符串连接\n" + num14);
            String num15 = str1.toUpperCase();
            String num16 = str2.toLowerCase();
            System.out.println("8.字符串中字符的大小写转换\n" + num15 + "\n" + num16);
                String num17 = str1.replace("abcDEF", "  武汉加油  ");
                String num18 = str2.replace("ABCdef", "  中国加油  ");
                System.out.println(num17 + str1.length());
                System.out.println(num18 + str2.length());
            String num19 = "  中南民族大学  ";
            System.out.println(num19 + num19.length());
            String num20 = num19.trim();
            System.out.println(num20 + num20.length());
            String num21 = "晚风,花间,寺中人";
            String[] num22 = num21.split(",");
            System.out.println(num21);
            for (int i = 0; i < num22.length; i++) {
                System.out.print(num22[i]);
            }
            System.out.println("\t" + num22.length);
    
        }
        public static void method3() {
            String num19 = "  中南民族大学  ";
            System.out.println(num19 + num19.length());
            String num20 = num19.trim();
            System.out.println(num20 + num20.length());
            String num21 = "晚风,花间,寺中人";
            String[] num22 = num21.split(",");
            System.out.println(num21);
            for (int i = 0; i < num22.length; i++) {
                System.out.print(num22[i]);
            }
            System.out.println("\t" + num22.length);
        }
    
    }
    
    /*
    String常用方法列表练习
     */
    public class StringTest {
        public static void main(String[] args) {
        method.method1();
        method.method2();
        method.method3();
        }
    }
    
    
    1.获取字符串的长度15
    2.获取字符在字符串中出现的位置
    4
    4
    6
    2
    3.获取字符串中某一位置的字符
    日
    4.截取字符串
    29日abcDEF
    20205.验证字符串开始或结束的字符
    true
    false
    6.字符串的比较
    1
    1
    false
    false
    7.字符串连接
    20181215日ABCdef2020年29日abcDEF
    8.字符串中字符的大小写转换
    202029日ABCDEF
    20181215日abcdef
    202029日  武汉加油  15
    20181215日  中国加油  17
      中南民族大学  10
    中南民族大学6
    晚风,花间,寺中人
    晚风花间寺中人	3
      中南民族大学  10
    中南民族大学6
    晚风,花间,寺中人
    晚风花间寺中人	3
    
    进程已结束,退出代码 0
    
    
    展开全文
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     设定字符串为“张三,你好,我是李四”  产生张三的密钥(keyPairZhang)  张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到...
  • java第二次作业

    2017-03-28 17:34:00
    Java第二次作业 (一)学习总结 ...使用“==”比较字符串的内容所比较的是字符串的内容和地址,若使用“==”str1和str2两字符串进行比较,则发现比较双方不相等。 public class Stringzt { public static vo...

    Java第二次作业

    (一)学习总结
    1.学习使用Eclipse关联jdk源代码,查看String类的equals()方法,截图,并学习其实现方法。举例说明equals方法和==的区别。

    使用“==”比较字符串的内容所比较的是字符串的内容和地址,若使用“==”对str1和str2两字符串进行比较,则发现比较双方不相等。

    public class Stringzt {
    public static void main(String[] args){
        String str1=new String("ABC");
        String str2=new String("ABC");
        String str3=str2;
        System.out.println("str1==str2\t"+(str1==str2));
        System.out.println("str1==str3\t"+(str1==str3));
        System.out.println("str3==str2\t"+(str3==str2));
    
         }
    } 
    
    
    输出结果:
    
        str1==str2  false
        str1==str3  false
        str3==str2  true

    输出结果:

    使用equals对两者进行比较的话,则比较的仅仅是两字符串的***内容***,内容相等,则双方相等。
    
    public class Stringzt {
    public static void main(String[] args){
        String str1=new String("ABC");
        String str2=new String("ABC");
        String str3=str2;
        System.out.println("str1 equals str2\t"+(str1.equals(str2)));
        System.out.println("str1 equals str3\t"+(str1.equals(str3)));
        System.out.println("str3 equals str2\t"+(str3.equals(str2)));
    
       }
    }

    输出结果:

    str1 equals str2    true
    str1 equals str3    true
    str3 equals str2    true

    2.什么是构造方法?什么是构造方法的重载?下面的程序是否可以通过编译?为什么?
    2.1
    1081503-20170327130541248-230082195.png

    此程序不能通过编译,图中所示位置缺少参数。
    构造方法及构建方法的重载:
    2.2构造方法的格式如下:

    class 类名称{
    访问权限 类名称(类型1 参数1,类型2 参数2){
        程序语句:
        ...
    }

    }
    2.3只要每个构造方法的参数类型或参数数量不同时,就可以实现构造方法的重载。
    3.运行下列程序,结果是什么?查阅资料,分析为什么。

    public class Test {
    public static void main(String args[]) { 
        double a = 0.1;
        double b = 0.1;
        double c = 0.1;
        if((a + b + c) == 0.3){
            System.out.println("等于0.3");
        }else {
            System.out.println("不等于0.3");
        }
    }     

    }
    结果:
    不等于0.3
    (a+b+c)的实际答案是:
    1081503-20170327133706608-1159436978.png

    其原因是精度不够,不能直接进行加法运算。

    为了处理精度损失的问题,可以使用java.math.BigDecimal类,查阅JDK帮助文档或教材p378,对上述程序进行修改。
    修改后的程序:

     import java.math.BigDecimal;
    public class test {
    public static void main(String args[]) { 
              BigDecimal a = new BigDecimal ("0.1");
              BigDecimal b = new BigDecimal ("0.1");
              BigDecimal c = new BigDecimal ("0.1");     
              if(a.add(b).add(c).doubleValue()==0.3){
                 System.out.println("等于0.3");
              }else {
                  System.out.println("不等于0.3");
              }
          }

    }

    4.运行下列程序,结果是什么?分析原因,应如何修改.

    public class Test {
    public static void main(String[] args) {
        MyClass[] arr=new MyClass[3];
        arr[1].value=100;
    }

    }
    class MyClass{
    public int value=1;
    }

    运行结果:
    1081503-20170327230321498-1843039388.png
    修改后:未按照数组方式来定义

    public class Test {
    public static void main(String[] args) {
        MyClass arr=new MyClass();
        arr.value=100;
    }

    }
    class MyClass{

    public int value=1;

    }

    5.在一个10000次的循环中,需要进行字符串的连接操作,那么,应该使用String类还是StringBuffer类,为什么?性能有差异吗?能否写出测试代码证明你的结论。(可查阅资料)
    String类:
    1081503-20170328082729139-1784900137.png
    StringBufffer类:
    1081503-20170328083743014-1733521395.png
    由两时间比较,使用StringBuffer的时间相对来说要比String少,运行速度要快。

    6.其他需要总结的内容。好多细节以前没有注意到,比如声明的方法,精度问题之类的。数组,字符串也突然间感到不太熟悉了。

    (二)实验总结
    实验内容:

    1.评分系统:一共10个评委,满分10分,假设有5个选手,分别由评委打分,去掉一个最高分和一个最低分后的平均分为该选手得分,将选手的得分从高到低进行输出。定义适当的方法。
    设计思路:
    设置一个Scanner类进行输入数组的数据。两个for的循环,10个评委依次为5个选手评分,对每次进行依次输入分数。

    Scanner sc=new Scanner(System.in);
        
        for( i=1;i<6;i++){
            int score1[]=new int[10];
            System.out.printf("10位评委各个为第%d号选手得分为\n",i);
            for( j=1;j<11;j++){
                score1[i]=sc.nextInt();
            }
         } 

    然后依次设了求平均分数函数(去掉一个最高数和一个最低数之后求8个评委所评分数)public static double avg(int score[])考虑到平均数的精度问题所以设成double类同时调用函数max(score)min(score)用来减去一个最高数和一个最低数。其他函数的分别调用为public static double max(int score[]),public static double min(int score[]),public static Object[] sort(int score[])
    出现的问题:函数的调用问题及程序不能顺利运行,出现很多错误。
    2.Email验证:在各种应用中,需要对用户输入的email地址进行验证,编写一个方法,判断一个email地址是否有效。(判断条件:A:@和.同时存在 B: @在.之前 C: 不能@开头 D: 以com|cn|net|gov|edu|org结尾 )
    设计思路:使用boolean方法进行判断,如果依次符合A,B,C,D的条件。则判为正确进行下一步。

    boolean  test=false;
      if(str1.startsWith("@"))
      {test=false;}
      else{test=true;}
             
      if(test){System.out.println(str1+"为正确格式");}
      else{System.out.println(str1+"为错误格式");

    出现的问题:我嵌套使用此方法不仅麻烦凌乱而且有局限性问题很大,由于没有想到其他解决方法,所以没解决此问题。
    3.统计文件:输入一个字符串,包含各种文件类型的文件名。文件名之间用“,”分隔,要求将各个文件名的首字母大写后分别输出,并统计各种类型文件的文件个数。
    设计思路:我想的是先建立一个String 型的str1的字符串,各文件名之间用逗号隔开,然后使用String s[]=str1.split(",")方法拆分成个体文件名以数组的方法分别输出。使用s[i].toUpperCase(0,1)方法将文件类型名首字母大写,用s[i].indexOf(".exe")方法将个文件分类。
    出现的问题:出现问题太多,没写完。

    4.身份证识别:(未完成)公民身份证号码由十八位数字组成。从左至右依次为:六位地址码,八位出生日期码,三位顺序码和一位校验码。顺序码的奇数分配给男性,偶数分配给女性。编写一个识别身份证基本信息的小工具,输入一个居民身份证号,则输出居民所属省份(直辖市、自治区),生日(格式:xxxx-xx-xx)和性别信息。

    (三)代码托管(务必链接到你的项目)

    码云commit历史截图
    1081503-20170328173218404-1030722374.png

    转载于:https://www.cnblogs.com/zhaotong189800/p/6635956.html

    展开全文
  • java基本算术训练

    2019-08-28 00:02:05
    java基本算术训练编程实现1+2+3+、、、+100编程实现1+3+5+7+、、、+101编程实现输出十个随机整数,值在0-100之间以上生成的十个随机整数进行排序设有两字符串A、B构成的集合...编程实现1+2+3+、、、+100 ...

    编程实现1+2+3+、、、+100

    废话不多说直接上代码,这里直接展示代码实现部分和代码运行结果。

    //创建输出函数快捷键sout
    int sum1 = 0, sum2 = 0;
    //编程实现1+2+3+...+100
    for (int i =1; i <= 100; i++) {
        sum1 += i;
    }
    System.out.println("\nthe Sum of nature numbers within 100 is :" + sum1);
    

    编程实现1+3+5+7+、、、+101

    //编程实现1+3+5+7+9+...+101
    int c = 1;//c用来存储奇数
    for (int i = 1; i <= 50; i++) {
        sum2 += c;
        c += 2;
    }
    System.out.println("\nthe Sum of odd numbers within 101 is :" + sum2);
    

    编程实现输出十个随机整数,值在0-100之间

    //编程实现输出10个随机整数,值在0-100之间
    Random r = new Random(30);//创建一个新的伪随机数生成器
    //定义一个数组来承接生成的随机数
    int[] ran = new int[10];
    System.out.println("\n生成的随机数为:");
    for (int i = 0; i < 10; i++) {
        int t1 = r.nextInt(100);
        ran[i] = t1;
        System.out.printf(t1 + "   ");
    }
    

    对以上生成的十个随机整数进行排序

    在此处进行排序我使用了两种方式分别实现了对于十个数字的排序功能,分别为选择法冒泡排序法。两种排序方式都可以,故我使用这两种方式一个实现正序排列一个实现了倒序排列。在具体应用中两种都可以。

    //创建方法使用快捷键 Alt+Insert
    //方法一,选择法,第一次循环都和第一个比较,把最小的放在最前边
    public static int[] sort(int[] a) {
        int[] b=new int[10];
        for (int i = 0; i < 10; i++) {
            for (int j = i+1; j <10; j++) {
                if(a[i]>a[j]){
                    int temp=a[i];
                    a[i]=a[j];
                    a[j]=temp;
                }
            }
        }
        return a;
    }
    //方法二:冒泡排序法,相邻两个进行比较,将最大的放到最后边
    public static int[] sort1(int[] a) {
        for(int i=0;i<10;i++){
            for(int j=0;j<10-i-1;j++){
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        return a;
    }
    
    

    设有两字符串A、B构成的集合,字符串内容值为以下所示:

    A:{a,b,c,d,e,f,g,in,off,about,get}
    B:{f,g,a,come,get,go}

    试求出

    1. 求出集合A、B的交集;
    2. 只在集合A中出现的字符串集合;
    3. 集合A、B的并集。

    以下则分别实现三个功能,首先实现要求1,求出AB集合的交集

          //返回集合A和集合B交集
    public static String[] samestr(String[] a,String[] b) {
        String[] aa=new String[20];
        int k=0;
        for (int i=0;i<a.length;i++){
            for(int j=0;j<b.length;j++){
                if(a[i]==b[j]){
                    aa[k]=a[i];
                    k++;
                    break;
                }
            }
        }
        return aa;
    }
    

    接下来实现要求2,求出只在A中出现的字符串集合

    //返回字符串a独有的集合
    public static ArrayList diffstr(String[] a, String[] b) {
        ArrayList aa=new ArrayList();//用来存储字符串a
        ArrayList bb=new ArrayList();//用来存储字符串b
        for (int i = 0; i < a.length; i++) {
            aa.add(a[i]);
        }
        for (int i = 0; i < b.length; i++) {
            bb.add(b[i]);
        }
        //移除aa中包含的bb
        aa.removeAll(bb);
        return aa;
    }
    
    

    最后再来实现要求3,求A、B集合的并集

    //返回AB集合并集
    public static ArrayList gatherstr(String[] a,String[] b) {
        ArrayList aa=new ArrayList();
        for (int i = 0; i < a.length; i++) {
            aa.add(a[i]);
        }
        for (int i = 0; i < b.length; i++) {
            aa.add(b[i]);
        }
        return aa;
    }
    
    

    程序运行截图

    以下我展示出程序运行后的结果:

    在这里插入图片描述

    全部的java代码

    最后我还提供出此次练习的全部java源码,供大家一起学习讨论。代码中有什么不足之处,欢迎大家斧正。

    package main.java.demo;
    
    import java.util.ArrayList;
    import java.util.Random;
    
    /**
     * Created with IntelliJ IDEA.
     * User: kingback
     * Author:king@王延凯
     * Date: 2019/4/6
     * Time: 20:39
     * Description: No Description
     */
    public class HelloWorld {
        //创建main函数快捷键psvm
        public static void main(String[] args) {
    
            //创建输出函数快捷键sout
            int sum1 = 0, sum2 = 0;
            //编程实现1+2+3+...+100
            for (int i =1; i <= 100; i++) {
                sum1 += i;
            }
            System.out.println("\nthe Sum of nature numbers within 100 is :" + sum1);
            //编程实现1+3+5+7+9+...+101
            int c = 1;//c用来存储奇数
            for (int i = 1; i <= 50; i++) {
                sum2 += c;
                c += 2;
            }
            System.out.println("\nthe Sum of odd numbers within 101 is :" + sum2);
    
            //编程实现输出10个随机整数,值在0-100之间
            Random r = new Random(30);//创建一个新的伪随机数生成器
            //定义一个数组来承接生成的随机数
            int[] ran = new int[10];
            System.out.println("\n生成的随机数为:");
            for (int i = 0; i < 10; i++) {
                int t1 = r.nextInt(100);
                ran[i] = t1;
                System.out.printf(t1 + "   ");
            }
    
            int[] aa = new int[10];
            aa = sort(ran);
            System.out.println("\n\n排序后的结果为:");
            for (int i = 0; i < 10; i++) {
                System.out.print(aa[i] + "   ");
            }
            //多行注释ctrl+shift+/
           /* for(int i=0;i<10;i++){
                System.out.println(ran[i]);
            }*/
    
            //设有两字符串构成的集合,字符串内容如下所示
            String[] str = {"a", "b", "c", "d", "e", "f", "g", "in", "off", "about", "get"};
            String[] str1 = {"f", "g", "a", "come", "get", "go"};
            String[] togather = new String[20];
            String[] diff = new String[20];
    
            //要求找出两个集合的交集,并集
            togather = samestr(str, str1);
            //输出AB的交集
            System.out.print("\n\nAB的交集: ");
            for (int i = 0; i < togather.length; i++) {
                if (togather[i] != null) {
                    System.out.print(togather[i] + "   ");
                }
            }
            //输出只在A中出现的字符串
            System.out.println("\n\n只在A中出现的集合: ");
            ArrayList aaa = new ArrayList();
            aaa = diffstr(str, str1);
            for (int i = 0; i < aaa.size(); i++) {
                System.out.printf(" " + aaa.get(i) + " ");
            }
            //输出AB集合并集
            ArrayList bbb=gatherstr(str,str1);
            System.out.println("\n\nAB的并集为: ");
            for (int i = 0; i < bbb.size(); i++) {
                System.out.print(" "+bbb.get(i)+" ");
            }
        }
        //创建方法使用快捷键 Alt+Insert
        //方法一,选择法,第一次循环都和第一个比较,把最小的放在最前边
        public static int[] sort(int[] a) {
            int[] b=new int[10];
            for (int i = 0; i < 10; i++) {
                for (int j = i+1; j <10; j++) {
                    if(a[i]>a[j]){
                        int temp=a[i];
                        a[i]=a[j];
                        a[j]=temp;
                    }
                }
            }
            return a;
        }
        //方法二:冒泡排序法,相邻两个进行比较,将最大的放到最后边
        public static int[] sort1(int[] a) {
            for(int i=0;i<10;i++){
                for(int j=0;j<10-i-1;j++){
                    if(a[j]>a[j+1]){
                        int temp=a[j];
                        a[j]=a[j+1];
                        a[j+1]=temp;
                    }
                }
            }
            return a;
        }
        //返回集合A和集合B交集
        public static String[] samestr(String[] a,String[] b) {
            String[] aa=new String[20];
            int k=0;
            for (int i=0;i<a.length;i++){
                for(int j=0;j<b.length;j++){
                    if(a[i]==b[j]){
                        aa[k]=a[i];
                        k++;
                        break;
                    }
                }
            }
            return aa;
        }
        //返回字符串a独有的集合
        public static ArrayList diffstr(String[] a, String[] b) {
            ArrayList aa=new ArrayList();//用来存储字符串a
            ArrayList bb=new ArrayList();//用来存储字符串b
            for (int i = 0; i < a.length; i++) {
                aa.add(a[i]);
            }
            for (int i = 0; i < b.length; i++) {
                bb.add(b[i]);
            }
            //移除aa中包含的bb
            aa.removeAll(bb);
            return aa;
        }
        //返回AB集合并集
        public static ArrayList gatherstr(String[] a,String[] b) {
            ArrayList aa=new ArrayList();
            for (int i = 0; i < a.length; i++) {
                aa.add(a[i]);
            }
            for (int i = 0; i < b.length; i++) {
                aa.add(b[i]);
            }
            return aa;
        }
    
    
    展开全文
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     设定字符串为“张三,你好,我是李四”  产生张三的密钥(keyPairZhang)  张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     设定字符串为“张三,你好,我是李四”  产生张三的密钥(keyPairZhang)  张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     设定字符串为“张三,你好,我是李四”  产生张三的密钥(keyPairZhang)  张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到...
  • 1本章学习总结 (1)一些java的基本语法(2)java API文件(3)使用码云管理自己的代码...(2)为什么要尽量频繁的对字符串的修改操作应该是用StringBuilder而不是String? 因为对string操作需要进行将字符串删除然...
  • 1、对字符串进行base64解码生成中间串 s; 2、然后,取key为发送数据时的key,取s的前10个字节作为初始向量iv,之后解密 利用key和iv对串s的16字节之后的部分进行AES解密即可 附上文档截图: 不得不服python的...
  • java学生信息管理模块

    2015-03-19 17:40:35
    基于java纯代码的简易学生信息管理...对于要修改学生的信息,采用简单的Json格式处理,自定义处理此格式(通过检索字符串,截取输入的要修改的信息。)。满足非法信息的重新录入,并附有该程序的运行截图。可扩充性。
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     设定字符串为“张三,你好,我是李四”  产生张三的密钥(keyPairZhang)  张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节  通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到...
  • 设定字符串为“张三,你好,我是李四” 产生张三的密钥(keyPairZhang) 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节 通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后...
  • 设定字符串为“张三,你好,我是李四” 产生张三的密钥(keyPairZhang) 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节 通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后...
  • 设定字符串为“张三,你好,我是李四” 产生张三的密钥(keyPairZhang) 张三生成公钥(publicKeyZhang)并发送给李四,这里发送的是公钥的数组字节 通过网络或磁盘等方式,把公钥编码传送给李四,李四接收到张三编码后...
  • 这个计算器的核心算法就是左边的字符串进行处理,得出右边的结果,其中要考虑到括号匹配、负号、乘除优先级等等问题,这一个算法写了200行。 因为字符串比较短,最多就几十,所以我的算法比较暴力,没有考虑时间和...
  • word源码java simba 一个基于SpringMVC的web框架, 初始化脚本在doc目录中, 目前只提供了mysql版本,ppt有基本的使用介绍, 由于时间关系并未包含所有的功能介绍。...字符串增加zip和gzip两个加解压
  • 字符串String类 2.书面作业 Q1.使用Eclipse关联jdk源代码(截图),并查看String对象的源代码?简单分析String对象的设计思路。 String对象不变,两种方式,一种是直接='string';,一种是=new String("strin...
  • 实例073 根据标点符号对字符串进行分行 实例074 将字符串的每个字符进行倒序输出 实例075 获取字符串中汉字的个数 实例076 批量替换某一类字符串 实例077 把异常与错误信息显示到窗体中 实例078 从字符串中...
  • 实例073 根据标点符号对字符串进行分行 实例074 将字符串的每个字符进行倒序输出 实例075 获取字符串中汉字的个数 实例076 批量替换某一类字符串 实例077 把异常与错误信息显示到窗体中 实例078 从字符串中...
  • 实例073 根据标点符号对字符串进行分行 实例074 将字符串的每个字符进行倒序输出 实例075 获取字符串中汉字的个数 实例076 批量替换某一类字符串 实例077 把异常与错误信息显示到窗体中 实例078 从字符串中...
  • 实例073 根据标点符号对字符串进行分行 实例074 将字符串的每个字符进行倒序输出 实例075 获取字符串中汉字的个数 实例076 批量替换某一类字符串 实例077 把异常与错误信息显示到窗体中 实例078 从字符串中...
  • 实例073 根据标点符号对字符串进行分行 实例074 将字符串的每个字符进行倒序输出 实例075 获取字符串中汉字的个数 实例076 批量替换某一类字符串 实例077 把异常与错误信息显示到窗体中 实例078 从字符串中...
  • 实例073 根据标点符号对字符串进行分行 92 实例074 将字符串的每个字符进行倒序输出 94 实例075 获取字符串中汉字的个数 94 实例076 批量替换某一类字符串 95 实例077 把异常与错误信息显示到窗体中 97 实例078 从...
  • 实例073 根据标点符号对字符串进行分行 92 实例074 将字符串的每个字符进行倒序输出 94 实例075 获取字符串中汉字的个数 94 实例076 批量替换某一类字符串 95 实例077 把异常与错误信息显示到窗体中 97 实例078 从...
  • 实例073 根据标点符号对字符串进行分行 92 实例074 将字符串的每个字符进行倒序输出 94 实例075 获取字符串中汉字的个数 94 实例076 批量替换某一类字符串 95 实例077 把异常与错误信息显示到窗体中 97 实例078 从...
  • 实例073 根据标点符号对字符串进行分行 92 实例074 将字符串的每个字符进行倒序输出 94 实例075 获取字符串中汉字的个数 94 实例076 批量替换某一类字符串 95 实例077 把异常与错误信息显示到窗体中 97 实例078 从...
  • 参考C语言版本,用Java写的LL(1)分析总控程序,该语法分析程序...本程序只能由'i','+','*','(',')'构成的以'#'结束的字符串进行分析,会输出每一步的分析栈、剩余字符、所用产生式。 Eclipse做的,有运行结果截图

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

java对字符串进行截图

java 订阅