JAVA-day06-String、util、集合初步-CSDN博客

本文详细介绍了Java中字符串的各种操作方法，包括判断、转换、替换等，并深入探讨了不同类型的集合类，如List、Set等的特点及使用场景。

/*
   判断：
        判断是否包含一个字符串
		  boolean contains(CharSequence s) 
        判断两个字符串的内容是否相同
		  boolean equals(Object anObject) 
        忽略大小写判断两个字符串的内容是否相同
		  boolean equalsIgnoreCase(String anotherString) 
         判断是否以某字符串开头
		   boolean startsWith(String prefix)
		 判断是否以某字符串结尾
		   boolean endsWith(String suffix) 
    转换：将字符数组转换成字符串
			  1:使用构造方法
				 String(char[] value) 
				 String(char[] value, int offset, int count) 
			  2:使用静态方法
				 static String copyValueOf(char[] data) 
				 static String copyValueOf(char[] data, int offset, int count) 
		  将字符串转成字符数组
              char[] toCharArray() 
 
		  将字节数组转成字符串
		      String(byte[] bytes) 
              String(byte[] bytes, int offset, int length)
			  String(byte[] bytes, String charsetName)//使用指定的编码将字节数组转换成字符成
		  将字符串转成字节数组
		      byte[] getBytes() 
 

		  将基本数据类型转换成字符串
		      String.valueOf()
    替换：
	     String replace(char oldChar, char newChar) 
 
	子串:
	     String substring(int beginIndex)  
		 String substring(int beginIndex, int endIndex) //包含起始位置，不包含结束位置，到结束位置的前一位
 
	转换，去除空格，比较:
	     大小写转换
		     String toLowerCase() 
             String toUpperCase()
		 将字符串两端的空格去掉
		     String trim() 
		 按字典顺序比较两个字符串
             int compareTo(String anotherString)
	切割: String[] split(String)

*/
class  Demo1
{
	public static void main(String[] args) 
	{
		//panDuan();
		//zhuanHuan();
		za();
	}

	public static void za()
	{
	   //替换
	   String ss = "abcdefg".replace("abc","xyz");
	   sop(ss);

	   //截取子串

	   String s2 = "eoriutoeirutio";
	   String s3 = s2.substring(3);
	   sop(s3);

	   String s4 = s2.substring(3,6);//包含起始位置，不包含结束位置，到结束位置的前一位
	   sop(s4);

	   //大小写转换

	   sop("owieuroi".toUpperCase());
	   sop("OUOIUO".toLowerCase());

	   //将字符串两端的空格去掉
	   sop("["+"  owiuerio  lskdjflskdfj    ".trim()+"]");


	   //比较字符串的大小

	   int num = "abd".compareTo("abd");//前边儿大于后边返回一个大于0 的数，前边儿小于后边返回一个小于0 的数，相等返回0
	   sop(num);

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

	   String str = "zhangsan,lisi,wangwu,liuneng";

       String[] arr = str.split(",");

	   for(int i=0;i<arr.length;i++)
		{
	         sop(arr[i]);
	      
	    }
	}


	public static void zhuanHuan()
	{
	   //把字符数组转成字符串
	   //使用构造方法
	   char[] ch = {'h','e','l','l','o'};
	   String str1 = new String(ch);
	   sop(str1);

	   sop(String.copyValueOf(ch));

	   //把字符串转成字符数组
	   char[]  arr = "oweuiroir".toCharArray();
	   for(int i=0;i<arr.length;i++)
		{
		  sop(arr[i]);
	    }

		//把字节数组转成字符串
		byte[]  b ={65,66,67,68,69};
		String str2 = new String(b);
        sop(str2);
		// String(byte[] bytes, int offset, int length)
		String str5 = new String(b,1,3);
        sop(str5);
		//把字符串转成字节数组

		String ss = "abcdef";
		byte[] bb = ss.getBytes();
		for(int i =0;i<bb.length;i++)
		{
			sop(bb[i]);
		}
        
		//把任意类型转成字符串 
		sop(String.valueOf(89));
		sop(String.valueOf(new Object()));//返回的是对象的字符串表示，相当于调用toString()方法的结果 
	
	
	
	}

	//判断
	public static void panDuan()
	{
		sop("hello world haha hehe".contains("world"));
		sop("wer".equals("ttt"));
		sop("abc".equalsIgnoreCase("ABC"));//忽略大小写比较两个字符串的内容是否相同
		sop("temp.txt".startsWith("temp"));
		sop("Demo1.java".endsWith("java"));
	}

	public static void sop(Object obj)
	{
	   System.out.println(obj);
	}
}

/*
1，模拟一个trim方法，去除字符串两端的空格。
	思路：
	1，判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。
		结尾处判断空格也是如此。
	2，当开始和结尾都判断到不是空格时，就是要获取的字符串。

2，将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
	思路：
	1，曾经学习过对数组的元素进行反转。
	2，将字符串变成数组，对数组反转。
	3，将反转后的数组变成字符串。
	4，只要将或反转的部分的开始和结束位置作为参数传递即可。

3，获取一个字符串在另一个字符串中出现的次数。
	"abkkcdkkefkkskk"
	思路：
	1，定义个计数器。
	2，获取kk第一次出现的位置。
	3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。
		每获取一次就计数一次。
	4，当获取不到时，计数完成。

4:对字符串中字符进行自然顺序排序。
  1:将字符串转成字符数组  toCharArray();
  2：排序//Arrays.sort();
  2：将数组转成字符串 

*/


class  Demo2
{
	public static void main(String[] args) 
	{
		String  ss = "     weiroeiur       ";
        sop("["+myTrim(ss)+"]");

		String s2 = "abcdef";
        String s3 = fanZhuan(s2,1,4);
		sop(s3);


		String str = "abkkcdkkefkkskk";

        int count = getCount(str,"kk");
		sop(count);
	}

   //获取一个字符串在另一个字符串中出现的次数。
   public static int getCount(String str,String key)
    {
	    int count =0;
		int index =0;
        while((index = str.indexOf(key))!=-1)
		{
			  count++;
              str = str.substring(index+key.length());
		}
        return count;
    }

	public static int getCount2(String str,String key)
    {
	    int count =0;
		int index =0;
        while((index = str.indexOf(key,index))!=-1)
		{
			  count++;
              index = index+key.length();
		}
        return count;
    }





	//将一个字符串进行反转。将字符串中指定部分进行反转，"abcdefg";abfedcg
    public static String fanZhuan(String str,int start,int end)
	{
	   //字符串转数组
	   char[] arr = str.toCharArray();

	   //对数组反转
       daoXu(arr,start,end);
	   //把数组转成字符串

	   return new String(arr);
	}
	//全部反转
    public static String fanZhuan(String str)
	{
	   return fanZhuan(str,0,str.length());
	}


	//对数组反转
	public static void daoXu(char[] arr,int start,int end)
	{
		for(int i=start,j=end-1;i<=j;i++,j--)
		{
			huan(arr,i,j);
		}
	}
   //交换
   public static void huan(char[] arr,int i,int j)
	{
        char temp;
		temp = arr[i];
		arr[i] =  arr[j];
		arr[j] = temp;
	  
    }










	//1，模拟一个trim方法，去除字符串两端的空格。

	public static String myTrim(String str)
	{
		int start = 0;
		int end = str.length()-1;

		while(str.charAt(start)==' ' && start<=end)
		{
			start++;
		}

		while(str.charAt(end)==' ' && start<=end)
		{
			end--;
		}

		return str.substring(start,end+1);
	}


	public static void sop(Object obj)
	{
	   System.out.println(obj);
	}
}

//StringBuffer： 一个字符串的容器，线程安全的
/*
存储：
    StringBuffer append(boolean b) 
    StringBuffer insert(int offset, boolean b) 
 

删除：
     StringBuffer delete(int start, int end) 
     StringBuffer deleteCharAt(int index)
 
修改：
     StringBuffer replace(int start, int end, String str) 
     void setCharAt(int index, char ch) 
 

获取：
     char charAt(int index) 
	 int indexOf(String str)
	 int indexOf(String str, int fromIndex)
	 int lastIndexOf(String str) 
          返回最右边出现的指定子字符串在此字符串中的索引。 
     int lastIndexOf(String str, int fromIndex) 
          返回最后一次出现的指定子字符串在此字符串中的索引。 
     int length() 
          返回长度（字符数）。 

反转：
     StringBuffer reverse() 

jdk1.5出现了StringBuilder ---线程不安全的  建议使用StringBuilder

jdk升级的原因：
1：提高效率
2：提高安全性
3：简化书写

*/

class  Demo3
{
	public static void main(String[] args) 
	{
		
           //add();
           fun();
	}

	public static void fun()
	{
		StringBuilder sb = new StringBuilder();
		//使用StringBuilder存储一个矩形
		for(int i=1;i<=5;i++)
		{
			for(int j=1;j<=10;j++)
			{
				sb.append("*");
			}
			sb.append("\r\n");
		}
		sop(sb.toString());
	}

	public static void add()
	{
		StringBuffer sb = new StringBuffer();
        StringBuffer f1 = sb.append("hello");
		StringBuffer f2 = sb.append(false);
		
		//sop(f1==sb);//添加内容之后返回的还是原有容器
		//sop(f2==sb);

		sb.append(45).append(6.7).append(345);
        //打印容器中的内容---需要调用toString()方法
		//从打印结果看，每次加入容器的内容，默认加载原有内容的后边
		sop(sb.toString());

		//在指定的位置插入数据
		sb.insert(0,"world");
		sop(sb.toString());


		//sb.delete(0,5);//包含起始位置，不包含结束位置
		//sop(sb.toString());

		sb.deleteCharAt(5);
		sop(sb.toString());

		//替换
		sb.replace(0,5,"haha");
		sop(sb.toString());

		sb.setCharAt(0,'s');
		sop(sb.toString());

         //反转

		 sb.reverse();
		 sop(sb.toString());
	}
	public static void sop(Object obj)
	{
	   System.out.println(obj);
	}
}

/*
包装类：
byte    Byte
short   Short
int     Integer
long    Long
char    Character
boolean Boolean
float   Float
double  Double

因为类可以定义属性和行为，方便使用
所以java为每种基本数据类型定义了包装类

包装类主要用来基本数据类型和字符串类型之间的转换


基本数据类型转字符串类型
      String Integer.toString(45);
	  String Double.toString(5.6);
字符串类型转基本数据类型
      int Integer.parseInt("123");
	  double  Double.parseDouble("34.56");
     
进制转换：十进制转其它进制

      Integer.toHexString();
	  Integer.toOctalString();
	  Integer.toBinaryString();
其它进制转十进制
      Integer.parseInt("数",进制);


*/

class  Demo4
{
	public static void main(String[] args) 
	{
		int num = 93847;
		if(num>Integer.MAX_VALUE)
             System.out.println("超范围了");

        

		String ss = Integer.toString(234);
		String s2 = Double.toString(34.5);
		sop(ss);
		sop(s2);


		int a = Integer.parseInt("345");
		double b = Double.parseDouble("34.5");

		sop(a+","+b);

        //其它进制转十进制
		Integer.parseInt("3c",16);
		Integer.parseInt("20",8);
		Integer.parseInt("111",2);

	}



	public static void sop(Object obj)
	{
	   System.out.println(obj);
	}
}

/*
jdk1.5的新特性


*/
class Demo5 
{
	public static void main(String[] args) 
	{
		Integer in =  new Integer(23);
		sop(in.intValue());

        Integer t = 23;//jdk1.5的新特性  自动装箱  new Integer(23);

		t = t+5;//先自动拆箱：t.intValue()+5   再装箱：new Integer(28)


		Integer  a = 128;
		Integer  b = 128;
		sop(a==b);//false
        
		Integer c = 127;
		Integer d = 127;
		
        //从jdk1.5开始,如果一个数在字节允许的范围之内(-128----+127)，并且之前已经定义过，那么再定义时使用已有的
		sop(c==d);//true


		byte x = 23;
		byte y = 23;
		sop(x==y);
		
	}
	
	public static void sop(Object obj)
	{
	   System.out.println(obj);
	}
}

//打包：
package com.qianfeng.android;
class  Person
{
	public static void main(String[] args) 
	{
		System.out.println("Person");
	}
}

//日期
import java.util.Date;
class Demo8 
{
	public static void main(String[] args) 
	{
		Date date = new Date();

		sop(date);//Tue Dec 02 14:14:26 CST 2014

		//把毫秒值的时间转成Date类型
		long time = System.currentTimeMillis();
		Date d  = new Date(time);
		sop(d);

		//把日期类型的转成毫秒值

		long t = d.getTime();
		sop(t);

	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

import java.text.DateFormat;
import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
class Demo9 
{
	public static void main(String[] args) throws ParseException
	{
		Date d = new Date();

		DateFormat df = DateFormat.getDateInstance();

		//只能使用DateFormat指定的格式显示日期和时间
		df = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.LONG);

		String date = df.format(d);

		sop(date);

		//按照自己的需求来显示日期时间

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd E HH:mm:ss");
        String str = sdf.format(d);
		sop(str);


		//把字符串转成日期

		String ss = "2008-12-12";
		DateFormat dff = DateFormat.getDateInstance();
		Date  date2 = dff.parse(ss);
		sop(date2);



	}


	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

/*
java.util.GregorianCalendar[time=1417502448520,areFieldsSet=true,areAllFieldsSet
=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=288
00000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWee
k=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2014,MONTH=11,WEEK_OF_YEAR=49,WEEK_OF_MO
NTH=1,DAY_OF_MONTH=2,DAY_OF_YEAR=336,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=1,AM_PM=
1,HOUR=2,HOUR_OF_DAY=14,MINUTE=40,SECOND=48,MILLISECOND=520,ZONE_OFFSET=28800000
,DST_OFFSET=0]
*/
import java.util.Calendar;
class Demo10 
{
	public static void main(String[] args) 
	{
        String[] months ={"1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"};
		String[] weeks = {"","星期日","星期1","星期2","星期3","星期4","星期5","星期6",};
		Calendar c = Calendar.getInstance();
		int month = c.get(Calendar.MONTH);
		int week = c.get(Calendar.DAY_OF_WEEK);


		String m = months[month];
		String w = weeks[week];
		
		sop(c.get(Calendar.YEAR)+"年");
		sop(m);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		sop(w);


		
	}


	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

import java.util.Random;
class Demo11 
{
	public static void main(String[] args) 
	{
		sop(Math.ceil(34.4));//返回大于这个数的最小整数
		sop(Math.floor(34.4));//返回小于这个数的最大整数

		sop(Math.pow(2,3));
       
	    for(int i=1;i<=10;i++)
		{
		   sop((int)Math.ceil(Math.random()*10));
		}

        Random r = new Random();

		for(int i=1;i<=10;i++)
		{
			sop(r.nextInt(6)+1);
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

/*
                同一个类中      同一个包但不同一个类      不同的包有继承关系      不同的包没有继承关系

 private         能             不能                         不能                   不能
 
 默认            能              能                          不能                   不能

 protected       能              能                          能                     不能
 
 public          能              能                          能                      能
*/
class  
{
	public  static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

/*
需求：存储不同类型的对象
数组：只能存储同一种类型的数据，而且长度是固定的
      Object [] obj = new Object();
	  obj[0] = new Person();
	  obj[1] = new Student();
集合：存储不同类型的对象
      会随着存储的对象的个数的增加，容量自动扩大
	  把集合看成容器，
	  集合存储的是对象的引用
*/
/*
Collection:是集合体系最顶层的接口,
最共性的方法:
添加：
   boolean add(Object o) 
   boolean addAll(Collection<? extends E> c)  
删除:
   boolean remove(Object o)  
   boolean removeAll(Collection<?> c)
   void clear()
判断:
   boolean contains(Object o) 
   boolean containsAll(Collection<?> c)
   boolean isEmpty() //判断集合是否为空
   boolean equals(Object o) 
获取：
   Iterator<E> iterator() //获取集合中的对象
   int size() //获取集合中对象的个数
 集合变数组：
   Object[] toArray()
*/

import java.util.*;
class  Demo13
{
	public static void main(String[] args) 
	{
		Collection coll = new ArrayList();

		coll.add("java");
		coll.add("adroid");
		coll.add(true);

		sop(coll);
        //删除成功返回true，否则返回false
		//sop(coll.remove("java"));
		//sop(coll);
        //清除集合中所有对象
		//coll.clear();
		//sop(coll.size());

		sop(coll.contains("java"));

		sop(coll.isEmpty());

		//集合变数组
		Object[] arr = coll.toArray();
		for(int i=0;i<arr.length;i++)
		{
			sop(arr[i]);
		}
	}



	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

//Iterator<E> iterator() //获取集合中的对象
import java.util.*;
class Demo14 
{
	public static void main(String[] args) 
	{
        Collection list = new ArrayList();
		list.add("java01");
		list.add("java02");
		list.add("java03");
		list.add("java04");

		Iterator ite = list.iterator();

		while(ite.hasNext())
		{
			Object obj = ite.next();
            String str = (String)obj;
			sop(str.toUpperCase());
		}
		
	}



	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

/*
Collection:
   List:存储的对象是有序的，可以重复
       ArrayList:底层使用的数据结构是数组，查找速度快，增删速度慢，线程不安全的
	   LinkedList:底层使用的数据结构是链表，查找速度慢，增删速度快，线程不安全的
	   Vector:底层使用的数据结构是数组，查找速度快，增删速度慢，线程安全的


   Set:存储的对象是无序的，不可以重复

List：特有方法，可以操作下标

增：
    void add(int index, E element) 
    boolean addAll(int index, Collection<? extends E> c) 

删
   E remove(int index) 

改
   E set(int index, E element)

查
     ListIterator<E> listIterator() 
     返回此列表元素的列表迭代器（按适当顺序）。 
     ListIterator<E> listIterator(int index) 
     List<E> subList(int fromIndex, int toIndex) 
     E get(int index) 
*/
import java.util.*;

class  Demo15
{
	public static void main(String[] args) 
	{
		List list = new ArrayList();
        list.add("java01");
		list.add("java02");

		list.add(0,"android");
		sop(list);

		//Object obj = list.remove(1);
		//sop(obj);

		list.set(1,"ios");
		sop(list);

		Object obj2 = list.get(0);
		sop(obj2);

		Iterator ite = list.iterator();

		while(ite.hasNext())
		{
			Object object = ite.next();
			sop(object);
		}
        //可以节省内存
		for(Iterator it = list.iterator();it.hasNext();)
		{
			 sop(it.next());
		}


		for(int i=0;i<list.size();i++)
		{
				sop(list.get(i));
		}

		while(!list.isEmpty())
		{
			sop(list.remove(0));
		}
        

		
	}


	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

// ListIterator<E> listIterator() 
import java.util.*;
class Demo16 
{
	public static void main(String[] args) 
	{
        dieDai2();
		
	}

    //通过ListIterator可以在迭代集合的过程中，对集合进行添加，删除，修改
	public static void dieDai2()
	{
		List list = new ArrayList();
        list.add("java01");
		list.add("java02");
		list.add("java03");

		ListIterator ite = list.listIterator();
 
		while(ite.hasNext())
		{
			Object object = ite.next();
            if(object.equals("java02"))
				 ite.add("java04");
		}
		sop(list);
	
	}

    //在迭代的过程中不能使用集合对象对集合进行添加对象,否则会发生ConcurrentModificationException异常
	public static void dieDai()
	{
		List list = new ArrayList();
        list.add("java01");
		list.add("java02");
		list.add("java03");

		Iterator ite = list.iterator();
 
		while(ite.hasNext())
		{
			Object object = ite.next();
            if(object.equals("java02"))
				  ite.remove();
				//list.add("java04");//ConcurrentModificationException
		}
	}



	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

import java.util.*;
class Demo17 
{
	public static void main(String[] args) 
	{
		Vector v =  new Vector();

		v.add("apple");
		v.add("pear");
		v.add("banana");

		Enumeration enu = v.elements();

		while(enu.hasMoreElements())
		{
			Object obj = enu.nextElement();
			sop(obj);
		}
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}


}

//LinkedList

/*
addFirst();
addLast();

如果获取的对象不存在，会异常
getFirst();
getLast();

如果删除的对象不存在，会异常
removeFirst();
removeLast();

从jdk1.6开始出现替代方法

offerFirst()
offerLast()

//如果获取的对象不存在，返回null,不会异常
peekFirst()
peekLast()

如果删除的对象不存在，返回null,不会异常
pollFirst()
pollLast()

*/
import java.util.*;
class  Demo18
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();
		link.addFirst("001");
		link.addFirst("002");
		link.addFirst("003");

		sop(link);

        while(!link.isEmpty())
		{
			sop(link.removeFirst());
		}

		//link.removeLast();//.NoSuchElementException
		link.getLast();//.NoSuchElementException



	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

/*
实现堆栈或队列
*/
import java.util.*;

class MyQueue
{
	private LinkedList link;

	public MyQueue()
	{
		link = new LinkedList();
	}

	//入队
	public void enQueue(Object obj)
	{
		link.addFirst(obj);
	}
	//出队
	public Object deQueue()
	{
		return link.removeLast();
	}
    //队列是否为空
	public boolean isNull()
	{
		return link.isEmpty();
	}
}
class  Demo19
{
	public static void main(String[] args) 
	{
		MyQueue  mq =  new MyQueue();
		mq.enQueue("001");
		mq.enQueue("002");
		mq.enQueue("003");
		mq.enQueue("004");

		while(!mq.isNull())
		{
			sop(mq.deQueue());
		}
	}

	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}