Date 字符串 正则表达式 网址

Date 字符串  正则表达式 网址

不可变字符串 :

分类：

不可变字符串：不是对象，String 字符串本身不能发生改变(地址)，与指向字符串的引用无关

String s1="1000sjf";

可变字符串：StringBuilder/StringBuffer. 字符串本身可以发生变化，与指向字符串的引用无关

不可变字符串（string）的特点

1.常量一般放在常量区，

2.在堆区里面有一个特殊的存储空间（类似常量区），专门用来存字符串，

问题1：String str = new String(“abc”);内存如何？

常用方法：

public class Demo2 {

    public static void main(String[] args) {

        String s = "1000phone";

        //1.判断：

        //判断是否包含一个子字符串

        //boolean contains(CharSequence s) 

        System.out.println(s.contains("1000"));//true

        //判断两个字符串的内容是否相同

        //boolean equals(Object anObject) 

        System.out.println(s.equals("1000"));//false

        //忽略大小写判断两个字符串的内容是否相同

        //boolean equalsIgnoreCase(String anotherString) 

        System.out.println(s.equalsIgnoreCase("1000PHone"));//true

        //判断是否以某字符串开头

        //boolean startsWith(String prefix)

        System.out.println(s.startsWith("1000"));//true

        //判断是否以某字符串结尾

        //boolean endsWith(String suffix) 

        System.out.println(s.endsWith("phone"));//true

        

        

        //2.转换：将字符数组转换成字符串

        //1:使用构造方法

        //String(char[] value) 

        //String(char[] value, int offset, int count) 

        char[] arr = {'p','h','o','n','e'};

        String string1 = new String(arr);

        String string2 = new String(arr, 2, 3);

        System.out.println(string1+"     "+string2);

        //2:使用静态方法

        //static String copyValueOf(char[] data) 

        //static String copyValueOf(char[] data, int offset, int count) 

        //将字符串转成字符数组

        //char[] toCharArray() 

        char[] arr1 = s.toCharArray();

        System.out.println(arr1+" "+arr);

        //将字节数组转成字符串

        //String(byte[] bytes) 

        //String(byte[] bytes, int offset, int length)

        //String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符成

        byte[] bytes = {97,98,99,100};

        String string3 = new String(bytes);

        System.out.println(string3);

        //将字符串转成字节数组

        //byte[] getBytes() 

        byte[] bytes1 = string3.getBytes();

        System.out.println(bytes1[0]);

        //将基本数据类型转换成字符串

        //String.valueOf()

        String string4 = String.valueOf(true);

        System.out.println(string4);

        

        

        //3.替换：

        //String replace(char oldChar, char newChar) 

        String string5 = s.replace("1000", "haha");

        System.out.println(string5+"    s:"+s);

        //子串:

        //String substring(int beginIndex)  

        //String substring(int beginIndex, int endIndex) //包含起始位置，不包含结束位置，到结束位置的前一位

        String string6 = "http://www.baidu.com:80/a/b/a/a?name=bing&age=18";

        String subString1 = string6.substring(7);

        String subString2 = string6.substring(7,20);

        System.out.println(subString2);

        //转换，去除空格，比较:

        //大小写转换

        //String toLowerCase()   转成小写

        //String toUpperCase()   转成大写

        //将字符串两端的空格去掉

        //只能取出两边的,中间的不能去

        //String trim() 

        String string7 = "    1000  phone     ";

        System.out.println(string7.trim()+"haha");

        //按字典顺序比较两个字符串

        /*

         * 字典顺序:按照ASCII表比较当前的两个字符,ASCII码大的认为是大的字符

         * 规则:从左边第一个字符开始比较

         * 如果当前的字符不相同,直接认为ASCII大的字符串是大字符串,后面的字符停止比较

         * 当前字符比较的具体规则:使用前面的字符-后面的字符,返回差值.如果是负数,说明前面的字符串小于后面的.反之前面的大.

         * 如果当前的字符相同,再去比较第二个字符,依次往后推,如果比到最后都相同,则认为两个字符串相等,差值返回0.

         */

        //int compareTo(String anotherString)

        int value = s.compareTo("1000PHone");

        System.out.println(value);

        

        //4.切割: String[] split(String)

        //被作为刀的子字符串不会再被作为内容.

        String string8 = "a,b,c,d,e,f";

        String[] strings = string8.split(",");

        for (int i = 0; i < strings.length; i++) {

            System.out.println(strings[i]);

        }

        String string9 = "1.0.0.0.p.h.o.n.e";

        String[] strings1 = string9.split("\\.");//默认.是任意字符的意思,\\.将它转义成普通的.

        for (int i = 0; i < strings1.length; i++) {

            System.out.println("strings1:"+strings1[i]);

        }

    }

}

可变字符串

StringBuffer:出现在jdk1.0,线程安全，考虑了线程安全问题

StringBuilder:出现在jdk1.5,是线程不安全的，没有考虑线程安全问题

注意：在不考虑线程安全问题时，尽量使用StringBuilder,因为速度快，效率高

方法

public class Demo3 {

    public static void main(String[] args) {

        StringBuffer sBuffer = new StringBuffer();

        //1.存储：

        //StringBuffer append(boolean b)   从最后插入

        sBuffer.append("1000");

        sBuffer.append("phone");

        System.out.println(sBuffer);

        //StringBuffer insert(int offset, boolean b)   从指定位置插入

        sBuffer.insert(4, true);

        System.out.println(sBuffer);

        //2.删除：

        //StringBuffer delete(int start, int end)   删除一部分字符串

        //StringBuffer deleteCharAt(int index)  删除一个字符

        System.out.println(sBuffer.delete(4, 8));

        //3.修改：

        //StringBuffer replace(int start, int end, String str)  替换指定的子字符串

        //void setCharAt(int index, char ch) 修改一个字符



        //4.获取：

        //char charAt(int index) 

        System.out.println(sBuffer.charAt(0));

        //返回指定子字符串的下标  从左到右

        //int indexOf(String str)

        System.out.println(sBuffer.indexOf("phone"));

        //int indexOf(String str, int fromIndex)

        System.out.println(sBuffer.indexOf("phone",7));

        //int lastIndexOf(String str) 

        //返回指定子字符串(从右边开始计数)在此字符串第一次出现时的索引

        //int lastIndexOf(String str, int fromIndex) 

        //返回指定子字符串(从右边开始计数,范围:当前指定的位置-0)在此字符串第一次出现时的索引 

        //int length() 

        //返回长度（字符数）。 

        System.out.println(sBuffer.length());

        //5.反转：

        //StringBuffer reverse()

        System.out.println(sBuffer.reverse());

补充：更新软件的作用

1.修补bug

2.增加功能

3.增加系统的安全性

网址(http://www.baidu.com:80/a/b/a/a?name=bing&age=18)

客户端（app 网页）和服务器(不是机器，是一个应用)：通过网址交流

### 构成

协议：//域名：端口号/资源路径？查询条件

1.协议：是指定一个统一的规范

http:超文本传输协议，实现的是一个网络间的通信的一个通信规则

https协议：安全的HTTP协议–可以

2.域名/ip：标记网络上的唯一一台主机

3.端口号：标记同一台主机上的某一个服务器([0,65536]—可以省,默认80)

拆分

Date

Date:日期类，java.util.包含年月日时分秒

Data:数据类，装的时二进制文件，java.sql.只包含年月日

格式

格式转换器：

Fromat（）:格式转化器（将日期格式化成日期/时间字符串）；DateFormat:日期转换器

1.系统提供：DateFormat:(short long full default)

2.自定义格式：SimpleDateFormat

示例代码：

1.使用系统提供的默认的格式-DateFormat–提供了四种可选模式:short,long,full,default

//第一个参数用于指定日期格式   第二个参数用于指定时间格式

DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT);

String stringDate =  dateFormat.format(new Date());

System.out.println(stringDate);

//1993-02-03 23:23:12     1993/02/03 23:23:12

2.使用自定义的日期格式转换器实现自由转换----SimpleDateFormat

SimpleDateFormat simpleDateFormat = new  SimpleDateFormat(“yyyy/MM/dd  HH:mm:ss”);//HH代表24小时制

String stringDate1 = simpleDateFormat.format(new Date());

System.out.println(stringDate1);

Calendar（日历类）

单个的年月日

public class Demo8 {

    public static void main(String[] args) {

        //日历类

        Calendar calendar = Calendar.getInstance();

        System.out.println(calendar);

        

        //获取当前的Date类型的时间

        Date date = calendar.getTime();

        System.out.println(date);

        

        //获取指定的值

        int value = calendar.get(Calendar.DATE);

        System.out.println(value);

        

        //获取属性的最大值,最小值

        int value1 = calendar.getMaximum(Calendar.YEAR);

        int value2 = calendar.getMinimum(Calendar.YEAR);

        System.out.println(value1+"    "+value2);

    }

}

访问权限

1. public：只能修饰类、方法（含构造方法）、成员。其修饰的部分所有人都能访问；

2. .默认修饰符（friendly）：只能修饰类、方法（含构造方法）、成员变量。其修饰的部分只有同一包内的类能访问，对于这个包之外的所有类，这个成员是private的；

3. private：只能修饰方法（含构造方法）、成员变量。其修饰的部分只能在自身类中访问。例如将某类的构造方法设置为private，那么在其它类中就不能调用“new”来创建该类的实例，通常在该类中会对外提供一种方法，该方法能返回该类的实例；再例如我们经常将成员变量设置为private的，对外提供set/get方法对其进行访问，在set/get方法中可做一些比如权限检测等操作，而不是将域直接暴露给所有用户；

4. protected：只能修饰方法（含构造方法）、成员变量。

Arrays类:数组工具类，内部封装了大量的操作数组的方法

public class Demo9 {

    public static void main(String[] args) {

        //简单数据类型数组转字符串---方便我们对数组的内容进行查看

        int[] arr1 = {3,4,6,8,9};

        System.out.println(arr1);

        System.out.println(Arrays.toString(arr1));

        

        //数组转集合

        //简单数据类型数组转集合

        List list = Arrays.asList(arr1);

        System.out.println(list.size());//1  将整个简单数据类型的数组作为了集合的一个元素

        //引用数据类型数组转集合

        String[] strings = {"haha","hehe","hello"};

        List list2 = Arrays.asList(strings);

        System.out.println(list2.size());//3    //引用类型数组中的一个元素对应集合中的一个元素

        

        //注意点:

        //转过来的集合长度是固定,所以不能执行增加,删除.但是可以执行修改,更改,遍历

        //list2.add("java");

        list2.set(0, "BigData");

        System.out.println(list2);

        

        //二分查找

        int[] arr3 = {3,6,8,67,678};

        System.out.println(Arrays.binarySearch(arr3, 67));

    }

}

正则表达式

String qq = "8776545644";

//使用正则表达式

String regex = "[1-9]\\d{4,12}";

boolean istrue = qq.matches(regex);

System.out.println(istrue);

具体操作

匹配：

1.使用的是String类中的boolean matches(String regex)方法

2.示例代码：

tring s = “18910909090”;

String regex = “1[345789]\d{9}”;

boolean b = s.matches(regex);

System.out.println(b);

切割：

1.使用的是String类中的 String[] split(String regex)方法，依据正则表达式的字符串来切割

2.示例代码:

String s = “sdjof.srj.gojjg.ofoe.sjesd”;

String regex = “\.”;//.默认代表任意字符,要想使用.需要进行转义\.

String[] strings = s.split(regex);

for (String string : strings) {

System.out.println(“string:”+string);

}

替换:

1.使用的是String类中的 String replaceAll(String regex, String replacement),把字符串中符合正则表达式的内容替换成第二个参数的内容

2.示例代码：

String s = “sjfwfj4444sajose645sdgsjgrj3329889jsfjgowjsg888888888jsfjs”;

String regex = “\d{4,}”;

String place = “****”;

String newString = s.replaceAll(regex, place);

System.out.println(newString);

获取：

1.示例代码：要求:获取连续超过四个字母的子字符串

String s = “abc   hello   world       look    book    d    jwejfe”;

String regex = “[a-zA-Z]{5,}”;

//相当于将正则表达式进行了简单的转化,但是Pattern本身不具有获取数据的能力

Pattern pattern =  Pattern.compile(regex);

//具有获取数据的能力

Matcher matcher = pattern.matcher(s);

//matcher.find();//判断是否有符合当前表达式的内容

//matcher.group();//是获取内容

while (matcher.find()) {

String string = matcher.group();

System.out.println(string);

}