Implements。实例化接口;
Interface role{
Int fire;
}
Class magicstick implements weapom{
Public int fire{
Return 0;
}
}
字母拼接:直接使用stringbuffer ();
线程安全:同时只能被一个线程修改。不能同时多个修改;
没有“+”直接连接这回事;更安全。
对比
String。则没有这些特性、字符可以直接用“+”来进行连接
eclipse:
Ctrl+左键。打开jdk中的源码。就可以找到很多的东西。(按住ctrl后鼠标点击string);
Ctrl+f;寻找要找的方法:
正则表达是:给定的格式是不是制定的特定格式。灵活性。逻辑性。功能性很强
加减乘除都要用转义字符进行转义:。转义字符 \\ 斜杠
Main(){
String s=”sscffs+sda-sad”;
Patten p=pattern.compile(“fs\\+”);
Matcher m=p.matcher(s);
Pring(m.group());
//找到匹配fs+字符;有返回ture;
While(m.find())
{
Print(m.group);//用while循环输出多个匹配
}
System.out.println(pattern.matches(\\+fsf\\+,s));
//判断s中是否有+fsf+如果有返回ture.
a.CharAt()获取字符;
}
a. matches()特定字符对比。
while (true){
String str=sc.nextLine();
//if(str.matches("\\w{6,}"))//输入长大于6的字符。{6}特定长度为6的。{6,8}长度为6到8位这么长;[]特定字
\\w:输入任意字符;
if(str.matches("\\w+@\\w+\\.(cn|com|net)+")){
//str.matches("^[0-9]+[a-zA-z][o-9a-zA-z]{4,}");
System.out.println("输入正确");
break;
}
System.out.println("用户名不正确");
b. }
String str=sc.nextline();//表示输入的是字符窜。
List list=new arraylist();// 定义一个list
List.add(“”);
List.(2,””)
List.get(3);只有一个参数。即第几个数:从0开始。
当list赋给abc的对象。更改abc的属性。则list中也会跟这更改。因为应用的是同一块内存。
For循环。下标比增强for循环还快。
集合即容器;
package com.nteach;
public class Name {
private String Firstname,Lastname;
public Name(String firstname, String lastname) {
super();
this.Firstname = firstname;
this.Lastname = lastname;
}
public String getFirstname() {
return Firstname;
}
public void setFirstname(String firstname) {
Firstname = firstname;
}
public String getLastname() {
return Lastname;
}
public void setLastname(String lastname) {
Lastname = lastname;
}
@Override
public String toString() {
return "Name [Firstname=" + Firstname + ", Lastname=" + Lastname + "]";
}
}
package com.nteach;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class text {
public static void main(String[] args) {
Collection c=new HashSet();
c.add(new Name("f1","l1"));
c.add(new Name("f2","l2"));
Iterator i=c.iterator();
while(i.hasNext()){
Name n=(Name)i.next();
System.out.println(n.FirstName);
}
}
}
构造方法即给类最新执行的方法;
Interface:
Collection有两个子接口:set ;list;
Map不是collection的子接口;
Set中的数据对象没有顺序并且不可重复(值);
List的数据有顺序可以重复;
Map:定义了存储的key-value;
Iterator Iterator();迭代;
Object[] toarray();返回转换成数组;
Import 导入包关键字。Java.util.*;
Remove在移除的时候是先通过比较两个对象的hashcode和equals
Hashcode是将属性转换成哈希码。然后再对比。先做hashcode。总和通常相同的很少。为什么现在。因为速度比较快。
Equals是第二次比较。
网上找到:Java中的Hashtables
Java包含两个类,java.util.Hashtable 和java.util.HashMap,它们提供了一个多种用途的hashtable机制。这两个类很相似,通常提供相同的公有接口。但它们的确有一些重要的不同点,我在后面会讲到。
Hashtable和HashMap对象可以让你把一个key和一个value结合起来,并用put() 方法把这对key/value输入到表中。然后你可以通过调用get()方法,把key作为参数来得到这个value(值)。只要满足两个基本的要求, key和value可以是任何对象。注意,因为key和value必须是对象,所以原始类型(primitive types)必须通过运用诸如Integer(int)的方法转换成对象。
为了将一个特定类的对象用做一个key,这个类必须提供两个方法,equals() 和 hashCode()。这两个方法在java.lang.Object中,所以所有的类都可以继承这两个方法;但是,这两个方法在Object类中的实现一般没什么用,所以你通常需要自己重载这两个方法。
Equals ()方法把它的对象同另一个对象进行比较,如果这两个对象代表相同的信息,则返回true。该方法也查看并确保这两个对象属于相同的类。如果两个参照对象 是完全一样的对象,Object.equals()返回true,这就说明了为什么这个方法通常不是很适合的原因。在大多数情况下,你需要一个方法来一个 字段一个字段地进行比较,所以我们认为代表相同数据的不同对象是相等的。
HashCode()方法通过运用对象的内容执行一个哈希函数来生成一个int值。Hashtable和HashMap用这个值来算出一对key/value位于哪个bucket(哈希元)(或列表)中。
作为例子,我们可以查看一下String 类,因为它有自己的方法来实现这两个方法。String.equals()对两个String对象一个字符一个字符地进行比较,如果字符串是相同的,则返回true:
String myName = "Einstein";
// The following test is
// always true
if ( myName.equals("Einstein") )
{ ...
String.hashCode ()在一个字符串上运行哈希函数。字符串中每个字符的数字代码都乘以31,结果取决于字符串中字符的位置。然后将这些计算的结果相加,得到一个总数。这个 过程似乎很复杂,但是它确保能够更好地分布值。它也证明了你在开发你自己的hashCode()方法时,能够走多远,确信结果是唯一的。
例如,假设我要用一个hashtable来实现一个书的目录,把书的ISBN号码作为搜索键来进行搜索。我可以用String类来承载细节,并准备好了equals()和hashCode()方法(见列表1)。我们可以用put()方法添加成对的key/value到hashtable中(见列表2)。
Put()方法接受两个参数,它们都属于Object类型。第一个参数是key;第二个参数是value。Put()方法调用key的hashCode()方法,用表中的列表数来除这个结果。把余数作为索引值来确定该条记录添加到哪个列表中。注意,key在表中是唯一的;如果你用一个已经存在的key来调用put(),匹配的条目就被修改了,因此它参照的是一个新的值,而旧的值被返回了(当key在表中不存在时,put()返回空值)。
要读取表中的一个值,我们把搜索键用于get()方法。它返回一个转换到正确类型的Object参照:BookRecord br =
(BookRecord)isbnTable.get(
"0-345-40946-9");
System.out.println(
"Author: " + br.author+ " Title: " + br.title);
另一个有用的方法是remove(),其用法同get()几乎一样,它把条目从表中删除,并返回给调用程序。
你自己的类
如果你想把一个原始类型用做一个key,你必须创建一个同等类型的对象。例如,如果你想用一个整数key,你应该用构造器 Integer(int)从整数中生成一个对象。所有的封装类??如Integer、Float和Boolean都把原始值看做是对象,它们重载了 equals()和hashCode() 方法,因此,它们可以被用做key。JDK中提供的许多其它的类也是这样的(甚至Hashtable和HashMap类都实现它们自己的equals() 和hashCode()方法),但你把任何类的对象用做hashtable keys前,应该查看文件。查看类的来源,看看equals()和hashCode()是如何实现的,也很有必要。例如,Byte、Character、 Short和Integer都返回所代表的整数值作为哈希码。这可能适合,也可能不适合你的需求。
在Java中运用Hashtables
如果你想创建一个hashtable,这个hashtable运用你自己定义的一个类的对象作为key,那么你应该确信这个类的equals()和hashCode()方法提供有用的值。首先查看你扩展的类,确定它的实现是否满足你的需求。如果没有,你应该重载方法。
任何equals()方法的基本设计约束是,如果传递给它的对象属于同一个类,而且它的数据字段设定为表示同样数据的值,那么它就应该返回 true。你也应该确信,如果传递一个空的参数给该方法,那么你的代码返回false:public boolean equals(Object o)
{
if ( (o == null)
|| !(o instanceof myClass))
{
return false;
}
// Now compare data fields...
另外,在设计一个hashCode()方法时,应该记住一些规则。首先,该方法必须为一个特定的对象返回相同的值,而不管这个方法被调用了多少次 (当然,只要对象的内容在调用之间没有改变,在将一个对象用做一个hashtable的key时,应该避免这一点)。第二,如果由你的equals()方 法定义的两个对象是相等的,那么它们也必须生成相同的哈希码。第三,这更像是一个方针,而不是一个原则,你应该设法设计方法,使它为不同的对象内容生成不 同的结果。如果偶尔不同的对象正好生成了相同的哈希码,这也不要紧。但是,如果该方法只能返回范围在1到10的值,那么只能用10个列表,而不管在 hashtable中有多少个列表。
在设计equals()和hashCode()时,另一个要记住的因素是性能问题。每次调用put() 或get(),都包括调用hashCode()来查找正确的列表,当get()扫描列表来查找key时,它为列表中的每个元素调用equals()。实现 这些方法使它们尽可能快而有效地运行,尤其当你打算使你的类公开可用时,因为其它的用户可能想在执行速度很重要的情况下,在高性能的应用程序中运用你的 类。
Hashtable性能
影响hashtable功效的主要因素就是表中列表的平均长度,因为平均搜索时间与这个平均长度直接相关。很显然, 要减小平均长度,你必须增加hashtable中列表的数量;如果列表数量非常大,以至于大多数列表或所有列表只包含一条记录,你就会获得最佳的搜索效 率。然而,这样做可能太过分了。如果你的hashtable的列表数远远多于数据条目,那你就没有必要做这样的内存花费了,而在一些情况下,人们也不可能 接受这样的做法。
在我们前面的例子中,我们预先知道我们有多少条记录1,000。知道这点后,我们就可以决定我们的hashtable 应该包含多少个列表,以便达成搜索速度和内存使用效率之间最好的折中方式。然而,在许多情况下,你预先不知道你要处理多少条记录;数据被读取的文件可能会 不断扩大,或者记录的数量可能一天一天地发生很大的变化。
随着条目的增加,Hashtable和HashMap类通过动态地扩展表来处理这个问题。这两个类都有接受表中列表最初数量的构造器,和一个作为参数的负载系数(load factor):public Hashtable(
int initialCapacity,
float loadFactor)
public HashMap(
int initialCapacity,
float loadFactor)
将这两个数相乘计算出一个临界值。每次给哈希表添加一个新的条目时,计数就被更新,当计数超过临界值时,表被重新设置(rehash)。(列表数量 增加到以前数量的两倍加1,所有的条目转移到正确的列表中。)缺省的构造器设定最初的容量为11,负载系数是0.75,所以临界值是8。当第九条记录被添 加到表中时,就重新调整哈希表,使其有23个列表,新的临界值将是17(23*0.75的整数部分)。你可以看到,负载系数是哈希表中平均列表数量的上 限,这就意味着,在缺省情况下,哈希表很少会有许多包含不只一条记录的列表。比较我们最初的例子,在那个例子中,我们有1,000条记录,分布在10个列 表中。如果我们用缺省值,这个表将会扩展到含有1,500多个列表。但你可以控制这点。如果用负载系数相乘的列表数量大于你处理的条目数,那么表永远不会 重制,所以我们可以仿效下面的例子:// Table will not rehash until it
// has 1,100 entries (10*110):
Hashtable myHashTable =
new Hashtable(10, 110.0F);
你可能不想这么做,除非你没有为空的列表节省内存,而且不介意额外的搜索时间,这可能在嵌入系统中会出现这种情况。然而,这种方法可能很有用,因为重新设置很占用计算时间,而这种方法可以保证永远不会发生重新设置这种情况。
注意,虽然调用put()可以使表增大(列表数量增加),调用remove()不会有相反的结果。所以,如果你有一个大的表,而且从中删除了大部分条目,结果你会有一个大的但是大部分是空的表。
Hashtable和HashMap
Hashtable和HashMap类有三个重要的不同之处。第一个不同主要是历史原因。Hashtable是基于陈旧的Dictionary类的,HashMap是Java 1.2引进的Map接口的一个实现。
也许最重要的不同是Hashtable的方法是同步的,而HashMap的方法不是。这就意味着,虽然你可以不用采取任何特殊的行为就可以在一个多 线程的应用程序中用一个Hashtable,但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的 synchronizedMap()方法,它创建一个线程安全的Map对象,并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时,你不能切断Hashtable中的同步(比如在一个单线程的应用程序中),而且同步增加了很多处理费用。
第三点不同是,只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key,但任 意数量的条目可以是空的value。这就是说,如果在表中没有发现搜索键,或者如果发现了搜索键,但它是一个空的值,那么get()将返回null。如果 有必要,用containKey()方法来区别这两种情况。
一些资料建议,当需要同步时,用Hashtable,反之用HashMap。但是,因为在需要时,HashMap可以被同步,HashMap的功能 比Hashtable的功能更多,而且它不是基于一个陈旧的类的,所以有人认为,在各种情况下,HashMap都优先于Hashtable。
关于Properties
有时侯,你可能想用一个hashtable来映射key 的字符串到value的字符串。DOS、Windows和Unix中的环境字符串就有一些例子,如key的字符串PATH被映射到value的字符串C: \WINDOWS;C:\WINDOWS\SYSTEM。Hashtables是表示这些的一个简单的方法,但Java提供了另外一种方法。
Java.util.Properties类是Hashtable的一个子类,设计用于String keys和values。Properties对象的用法同Hashtable的用法相象,但是类增加了两个节省时间的方法,你应该知道。
Store()方法把一个Properties对象的内容以一种可读的形式保存到一个文件中。Load()方法正好相反,用来读取文件,并设定Properties对象来包含keys和values。
注意,因为Properties扩展了Hashtable,你可以用超类的put()方法来添加不是String对象的keys和values。这是不可取的。另外,如果你将store()用于一个不包含String对象的Properties对象,store()将失败。作为put()和get()的替代,你应该用setProperty()和getProperty(),它们用String参数。
好了,我希望你现在可以知道如何用hashtables来加速你的处理了
Iterator:迭代器、遍历元素的。主要有3种方法。
Boolean hasNext();//游标右边是否有元素;
Object next();返回游标右边的元素并将游标移动到下一个位置;
Void remove();删除游标走边的元素,在执行完next之后该操作只能执行一次
Collection c=new hashSet();
Iterator it=c.iterator();找到hashset然后把游标放到第一个元素前;
^Println(it.next()); 输出的是hashset中的第一个元素;输出的是没有顺序的。因为是hashset. 所以没有顺序。是随意输出的。
For(int I:a){//从数组中抽出一个数赋值给i;一个一个的取出来赋值;从第一个到最好一个这就是增强for循环
^print(i);}
Collection c=new arrayList();//要导入两个包。这句import java。Util.*;就等于把Util包中的类全部倒入
package com.nteach;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class text {
public static void main(String[] args) {
Collection<Name> c=new HashSet<Name>();
c.add(new Name("f1","l1"));
c.add(new Name("f2","l2"));
Iterator<Name> i=c.iterator();
while(i.hasNext()){
Name n=(Name)i.next();
System.out.println(n.Firstname);
}
for(Name i1:c){
System.out.println(i1.Firstname.toString());
}
}
}
package com.nteach;
public class Name {
String Firstname,Lastname;
public Name(String firstname, String lastname) {
super();
this.Firstname = firstname;
this.Lastname = lastname;
}
public String getFirstname() {
return Firstname;
}
public void setFirstname(String firstname) {
Firstname = firstname;
}
public String getLastname() {
return Lastname;
}
public void setLastname(String lastname) {
Lastname = lastname;
}
@Override
public String toString() {
return "Name [Firstname=" + Firstname + ", Lastname=" + Lastname + "]";
}
}
Sets1=new Hashset();
Sets2=new Hashset();
S1.add(“a”); S1.add(“b”); S1.add(“c”);
S2.add(“d”); S2.add(“a”); s3.add(“b”);
Set sn=new hashset(s1);直接在sn中方副本;
Sn.retainall(s2);取交集;
Set su=new hashset(s1);
Su.addall(s2);
^print(sn);//输出 a,b;
^print(su);//输出这几个数。也许顺序不同d,a,c,b;
List接口:
Object Get(int index);//下标
Object set(int index,object element);//下标,element:若有值 返回;
Object add(int index,object element);//下标,值:会覆盖,没返回
Object remove(int index);
Int indexof(object o);
Int lastIndexOf(object o);返回最后一个;
Listl1=new linkedlist();
For(int i=0;i<=;I++){li.add(“a”+i);}
Print(l1);
L1.add(3,”100”);
Print(l1);
L1.set(6,”a200”);
Print(l1);
Print((string)l1.get(2)+” ”);输出下标为2的值
Print(l1.indexof(“a3”));//输出a3的下标
li.remove(1);//除去下标为1的值
java.util.collections
collections提供了一些静态方法实现了基于List容器的一些常用的算法;
void sort(list)对list容器内德元素排序
void shuffle(list)对list容器内的对象进行随机排序
void reverse(list) 对list容器内德对象进行逆序排列。就是把list整个数组逆向排序。A.1=a.last… a.last=a.1
void fill(list,object)用一个特定的对象重写整个list容器
void copy(list dext,list src)将src list容器内容拷贝到dest List容器
Int binarysearch(list,key)折半查找、找出下标 必须先排列才能用。也就是先用 sort
自动封包
set s=new hashset();
s.add(new integer(100));
s.add(100);这就是自动封包。但是加不进去。因为是hashset;这句和上面一句相同。
//
For(int i=0;i<list.size();i++){
String str=(string)list.get(i);
System.out.print(str);
}
//可以化简:就是把list.size()与string str.都写到for外头。这样就减少了内存开销;因为没次循环都要执行size。和弄个对象;
循环可以用toarray先转成数组。然后用下标遍历。