javase09_String&Collection

最新推荐文章于 2024-10-09 21:21:46 发布

原创最新推荐文章于 2024-10-09 21:21:46 发布 · 609 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#javase

学习笔记专栏收录该内容

8 篇文章

订阅专栏

本文介绍了Java中的字符串处理技巧，包括排序、计数等，并详细讲解了StringBuffer、StringBuilder的用法。此外，还深入探讨了Java集合框架，如List、Set、Map的基本操作和特点。

----------------------------------------------------------------------------------------------String-----------------------------------------------------------------------------------------------------------

字符数组排序：

public class Test
{
	public static void main(String[] args)
	{
		String[] str1 = {"fdsaf","dsaf","awer"};
		sort(str1);
		for(String s : str1)
			System.out.println(s);
		
	}
	
	public static void sort(String[] str)
	{
		for(int i = 0;i < str.length;i++)
		{
			for(int j  = i + 1; j < str.length ;j++)
			{
				if(str[i].compareTo(str[j]) > 0)
				{
					String temp = str[j];
					str[j] = str[i];
					str[i] = temp;
				}
			}
		}
	}
	
}

字符串出现的次数：

public int getKeyCount(String fromStr,String str)
	{
		int num = 0;
		int index = fromStr.indexOf(str,0);
		while(index != -1)
		{
			num ++;
			index = fromStr.indexOf(str,index+str.length());
		}
		return num;
	}

StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符。并且能够对其中的字符进行各种操作。

StringBuffer的特点：

1、是一个字符串缓冲区，其实就是一个容器。

2、长度是可变，任意类型都行。注意：是将任意数据都转成字符串进行存储。

3、容器对象提供很多对容器中数据的操作功能，比如：添加，删除，查找，修改。

4、所有的数据最终变成一个字符串。

将int数组元素转换成字符串并打印：

public class Test
{
	public static void main(String[] args)
	{
		StringBuffer sb = new StringBuffer();
		int[] num = {1,2,3,4,5,6};
		sb.append("[");
		for(int i=0; i<num.length;i++)
		{
			if(i != num.length -1)
				sb.append(num[i] + ",");
			else
				sb.append(num[i] + "]");
		}
		System.out.println(sb.toString());
	}
}

StringBuilder是线程不安全的，即就是在对容器操作的时候，不用去判断同步锁的问题，那么效率就高。并且API告诉我们优先采用StringBuilder类。

---------------------------------------------------------------------------------------------------------Collection------------------------------------------------------------------------------------------------------

集合中存储的都是对象的引用（地址）；
Collection定义了集合框架的共性功能。
1，添加
   add(e);
   addAll(collection);

2，删除
   remove(e);
   removeAll(collection);
   clear();

3，判断。
   contains(e);
   isEmpty();

4，获取
   iterator();
   size();

5，获取交集。
   retainAll();

6，集合变数组。
   toArray();

1，add方法的参数类型是Object。以便于接收任意类型对象。

2，集合中存储的都是对象的引用(地址)

什么是迭代器呢？
其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。

迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
List元素是有序的，元素可以重复，因为该集合体系有索引。Set元素是无序的，元素不可以重复。
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
LinkedList:特有方法：
addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。

offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
List中的contains方法是通过元素中的equals方法进行比较的
Set集合的功能是和Collection一样的。
HashSet是通过两个方法，hashCode和equals来保证元素唯一性的。首先判断hashCode，如果相同再判断equals.
TreeSet可以对集合中的元素进行排序，其底层数据结构是二叉树。保证元素唯一性的依据是compareTo方法返回0.

TreeSet排序的第一种方式：让元素自身具备比较性：元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的默认排序。
第二种方法：当元素自身不具备比较性时，或者具备的比较性不是所需要的时，需要让集合自身具有比较性，在集合初始化时，就有了比较方法。定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
比较器的定义，定义一个实现了Comparator接口的类。

import java.util.*;

public class Test
{
	public static void main(String[] args)
	{
		TreeSet al = new TreeSet((new MyComp()));
		al.add(new Person("lisi01",13));
		al.add(new Person("lisi02",11));
		al.add(new Person("lisi03",11));
		al.add(new Person("lisi01",12));
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName() + "  " + p.getAge());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	
	public static ArrayList singleElement(ArrayList al)
	{
		ArrayList get = new ArrayList();
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(!get.contains(obj))
				get.add(obj);
		}
		return get;
	}
}

class Person implements Comparable
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.age = age;
		this.name = name;
	}
	
	public String getName()
	{
		return name;
	}
	
	public int getAge()
	{
		return age;
	}
	
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age ==p.age;
	}
	
	public int hashCode()
	{
		return name.hashCode() + this.age * 23;
	}
	
	//元素自身具有比较方法
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Person))
			throw new RuntimeException("不是Person类");
		Person p = (Person)obj;
		if(this.age > p.age)
			return 1;
		if(this.age == p.age)
		{
			if(this.name.compareTo(p.name) > 0)
				return 1;
			if(this.name.compareTo(p.name) == 0)
				return 0;
		}
		return -1;
	}
}

//比较器
class MyComp implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		Person p1 = (Person)o1;
		Person p2 = (Person)o2;
		int num = p1.getName().compareTo(p2.getName());
		
		if(num == 0)
		{
			return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
		}
		return num;
	}
}

---------------------------------------------------------------------------------------------------------泛型---------------------------------------------------------------------------------------------------------

泛型是JDK1.5之后出现的新特性，用于解决安全问题，是一个类型安全机制。
好处：
1：将运行时期出现的问题ClassCastException转移到了编译时期，让程序安全隐患减少。
2.避免了强制转换麻烦。

静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

<pre name="code" class="java">
public class Test
{
	public static void main(String[] args)
	{
		School<Student> s1 = new School<Student>();
		s1.print1("sd");
		s1.print2(new Student());
		//s1.print2(new Teacher()); Error
		School.print4(new Teacher());
	}
}

class School <T>
{	
	public void print1(Object obj)
	{
		System.out.println(obj);
	}
	
	public void print2(T t)
	{
		System.out.println(t);
	}
	
	public <T> void print3(T t)
	{
		System.out.println(t);
	}
	
	public static <T> void print4(T t)
	{
		System.out.println(t);
	}
}

class Student
{
	
}

class Teacher
{
	
}

？通配符泛型的限定：？ extends E:可以接收E类型或者E的子类型。上限。? super E :可以接收E类型或者E类型的父类型。下限。
Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
HashTable：顶层数据结构是哈希表，不可以存入null键null值该集合是线程同步的。效率低
HashMap：底层是哈希表数据结构，允许使用null键和null值，该集合是不同步的。效率高
TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Set底层就是使用Map集合。

Map中的put方法会返回一个值，如果存入的键值之前不存在，则返回null，反之返回之前该键值对应的值，并用新存入的值覆盖该值。keySet方法将Map中所有的值存入Set集合。因为Set方法具有迭代器，所以可以迭代方式取出所有的键，根据get方法。获取每个键对应的值。entrySet方法返回Map.Entry<k,v>

//通过两种方法取出Map集合中的所有元素
import java.util.*;
public class Test 
{

	public static void main(String[] args) 
	{
		Map<String,String> map = new HashMap<String,String>();
		map.put("01", "zhangsan1");
		map.put("02", "zhangsan2");
		map.put("03", "zhangsan3");
		
		//先获取集合中的所有键的Set集合，
		Set<String> keySet = map.keySet();
		Iterator<String> it1 = keySet.iterator();
		while(it1.hasNext())
		{
			String key = it1.next();
			System.out.println("key: " + key + "  value: " + map.get(key));
		}
		
		System.out.println();
		//将Map集合中的映射关系取出。存入到Set集合中
		Set<Map.Entry<String, String>> entrySet = map.entrySet();
		Iterator<Map.Entry<String, String>> it = entrySet.iterator();
		while(it.hasNext())
		{
			Map.Entry<String, String> me = it.next();
			System.out.println("key: " + me.getKey() + "  value: " + me.getValue());
		}
	}

}

Map.Entry 其实Entry也是一个接口，他是Map接口中的一个内部接口。

interface Map
{
	public static interface Entry
	{
		public abstract Object getKey();
		public abstract Object getValue();
	}
}

能加static修饰符的接口都是内部接口

Collections,工具类，里面都是静态方法。常用方法sort,max,binarySearch，reverseOrder
Arrays，工具类，里面都是静态方法。asList可以将数组转换为List，方便用集合的思想和方法来操作数组中的元素。注意：将数组变为集合，不可以使用集合的增删方法。因为数组的长度是固定的。如果你增删，那么会发生UnsupportedOperationException.如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接变成集合中的元素。如果数组中的元素都是基本数据类型，那么会将该数组变成集合中的元素存在。
Collection 接口中的toArray方法可以将集合转换为数组.当指定类型的数组长度小于了集合的size，那么该方法的内部会创建一个新的数组。数组的长度为集合的size，当指定类型的数组长度大于了集合的size，就不会新创建数组。所以创建一个刚刚好的数组最优。集合转换为数组是为了限定对元素的操作。
使用for循环遍历集合元素时只能获取集合元素，但是不能对集合进行操作。迭代器除了遍历，还可以进行remove集合中元素的动作。如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
在使用可变参数的时候，要将可变参数放在参数列表的最后。