锐客网

  1. 首页 > 睿知 > it技术 > >

java集合的应用代码 java常用集合

类型IT技术

各位大神高分求一个JAVA集合问题,请给出详细的代码import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.regex.Matcher;
【java集合的应用代码 java常用集合】import java.util.regex.Pattern;
public class Test {
public static String str = "[{TIME=2006-06, PRICE=246.91388889, AccountMethod=7, BW_VALUE=https://www.04ip.com/post/88888}, {TIME=2006-07, PRICE=305611.11111111, AccountMethod=1, BW_VALUE=7070120}, {TIME=2006-08, PRICE=246.91388889, AccountMethod=1, BW_VALUE=88888}, {TIME=2006-08, PRICE=246.91388889, AccountMethod=7, BW_VALUE=7777}]";
public static ListDemo demos = new ArrayListDemo();
public static MapString, Demo maps = new HashMapString, Demo();
public static Pattern p = Pattern.compile("\\{.*?\\}");
public static Pattern p_time = Pattern.compile("TIME=.*?,");
public static Pattern p_price = Pattern.compile("PRICE=.*?,");
public static Pattern p_account = Pattern.compile("AccountMethod=.*?,");
public static Pattern p_value = https://www.04ip.com/post/Pattern.compile("BW_VALUE=https://www.04ip.com/post/.*?\\}");
public static void main(String[] args) {
Matcher m = p.matcher(str);
while (m.find()) {
Demo demo = null;
String s = m.group();
String t = null;
Matcher m2 = null;
m2 = p_time.matcher(s);
if (m2.find()) {
t = m2.group();
t = t.substring(5, t.length() - 1);
if (maps.containsKey(t)) {
demo = maps.get(t);
m2 = p_price.matcher(s);
if (m2.find()) {
String p = m2.group();
demo.setPRICE(demo.getPRICE()" "
p.substring(6, p.length() - 1));
}
m2 = p_account.matcher(s);
if (m2.find()) {
String a = m2.group();
a = a.substring(14, a.length() - 1);
if (a.equals("7")) {
m2 = p_value.matcher(s);
if (m2.find()) {
String v = m2.group();
v = v.substring(9, v.length() - 1);
demo.setFree(Double.parseDouble(v)
demo.getFree());
}
} else {
m2 = p_value.matcher(s);
if (m2.find()) {
String v = m2.group();
v = v.substring(9, v.length() - 1);
demo.setCharge(Double.parseDouble(v)
demo.getCharge());
}
}
}
} else {
demo = new Demo();
demo.setTIME(t);
m2 = p_price.matcher(s);
if (m2.find()) {
String p = m2.group();
demo.setPRICE(p.substring(6, p.length() - 1));
}
m2 = p_account.matcher(s);
if (m2.find()) {
String a = m2.group();
a = a.substring(14, a.length() - 1);
if (a.equals("7")) {
m2 = p_value.matcher(s);
if (m2.find()) {
String v = m2.group();
v = v.substring(9, v.length() - 1);
demo.setFree(Double.parseDouble(v));
}
} else {
m2 = p_value.matcher(s);
if (m2.find()) {
String v = m2.group();
v = v.substring(9, v.length() - 1);
demo.setCharge(Double.parseDouble(v));
}
}
}
}
}
maps.put(t, demo);
}
System.out.println(getResult());
}
public static String getResult() {
StringBuffer sb = new StringBuffer();
sb.append("[");
IteratorString iter = maps.keySet().iterator();
while (iter.hasNext()) {
String key = iter.next();
Demo demo = maps.get(key);
String temp = null;
if (demo.getFree() != 0) {
if (demo.getCharge() != 0) {
temp = "{TIME="demo.getTIME()",PRICE="
demo.getPRICE()",charge="demo.getCharge()
",free="demo.getFree()"}";
} else {
temp = "{TIME="demo.getTIME()",PRICE="
demo.getPRICE()",free="demo.getFree()"}";
}
} else {
if (demo.getCharge() != 0) {
temp = "{TIME="demo.getTIME()",PRICE="
demo.getPRICE()",charge="demo.getCharge()
"}";
} else {
temp = "{TIME="demo.getTIME()",PRICE="
demo.getPRICE()"}";
}
}
sb.append(temp",");
}
sb.deleteCharAt(sb.length() - 1);
sb.append("]");
return sb.toString();
}
}
其中java集合的应用代码的Demo就是一个javabean 。
Java泛型集合的应用和方法泛型（Generic type 或者 generics）是对 Java 语言的类型系统的一种扩展，以支持创建可以按类型进行参数化的类 。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符，就像方法的形式参数是运行时传递的值的占位符一样 。
可以在集合框架（Collection framework）中看到泛型的动机 。例如，Map 类允许您向一个 Map 添加任意类的对象，即使最常见的情况是在给定映射（map）中保存某个特定类型（比如 String）的对象 。
因为 Map.get() 被定义为返回 Object，所以一般必须将 Map.get() 的结果强制类型转换为期望的类型 ， 如下面的代码所示：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
要让程序通过编译，必须将 get() 的结果强制类型转换为 String ， 并且希望结果真的是一个 String 。但是有可能某人已经在该映射中保存了不是 String 的东西，这样的话，上面的代码将会抛出 ClassCastException 。
理想情况下，您可能会得出这样一个观点，即 m 是一个 Map，它将 String 键映射到 String 值 。这可以让您消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中 。这就是泛型所做的工作 。
泛型的好处
Java 语言中引入泛型是一个较大的功能增强 。不仅语言、类型系统和编译器有了较大的变化，以支持泛型，而且类库也进行了大翻修，所以许多重要的类，比如集合框架，都已经成为泛型化的了 。这带来了很多好处：
类型安全 。泛型的主要目标是提高 Java 程序的类型安全 。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设 。没有泛型，这些假设就只存在于程序员的头脑中（或者如果幸运的话，还存在于代码注释中） 。
Java 程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String 列表”或者“String 到 String 的映射” 。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束 。类型错误现在就可以在编译时被捕获了，而不是在运行时当作 ClassCastException 展示出来 。将类型检查从运行时挪到编译时有助于您更容易找到错误，并可提高程序的可靠性 。
消除强制类型转换 。泛型的一个附带好处是，消除源代码中的许多强制类型转换 。这使得代码更加可读 ， 并且减少了出错机会 。
尽管减少强制类型转换可以降低使用泛型类的代码的罗嗦程度 ， 但是声明泛型变量会带来相应的罗嗦 。比较下面两个代码例子 。
该代码不使用泛型：
List li = new ArrayList();
li.put(new Integer(3));
Integer i = (Integer) li.get(0);
该代码使用泛型：
ListInteger li = new ArrayListInteger();
li.put(new Integer(3));
Integer i = li.get(0);
在简单的程序中使用一次泛型变量不会降低罗嗦程度 。但是对于多次使用泛型变量的大型程序来说，则可以累积起来降低罗嗦程度 。
潜在的性能收益 。泛型为较大的优化带来可能 。在泛型的初始实现中 ， 编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中 。但是更多类型信息可用于编译器这一事实，为未来版本的 JVM 的优化带来可能 。
由于泛型的实现方式，支持泛型（几乎）不需要 JVM 或类文件更改 。所有工作都在编译器中完成，编译器生成类似于没有泛型（和强制类型转换）时所写的代码，只是更能确保类型安全而已 。
泛型用法的例子
泛型的许多最佳例子都来自集合框架，因为泛型让您在保存在集合中的元素上指定类型约束 。考虑这个使用 Map 类的例子，其中涉及一定程度的优化，即 Map.get() 返回的结果将确实是一个 String：
Map m = new HashMap();
m.put("key", "blarg");
String s = (String) m.get("key");
如果有人已经在映射中放置了不是 String 的其他东西 ， 上面的代码将会抛出 ClassCastException 。泛型允许您表达这样的类型约束，即 m 是一个将 String 键映射到 String 值的 Map 。这可以消除代码中的强制类型转换，同时获得一个附加的类型检查层，这个检查层可以防止有人将错误类型的键或值保存在集合中 。
下面的代码示例展示了 JDK 5.0 中集合框架中的 Map 接口的定义的一部分：
public interface MapK, V {
public void put(K key, V value);
public V get(K key);
}
注意该接口的两个附加物：
类型参数 K 和 V 在类级别的规格说明 ， 表示在声明一个 Map 类型的变量时指定的类型的占位符 。
在 get()、put() 和其他方法的方法签名中使用的 K 和 V 。
为了赢得使用泛型的好处 ， 必须在定义或实例化 Map 类型的变量时为 K 和 V 提供具体的值 。以一种相对直观的方式做这件事：
MapString, String m = new HashMapString, String();
m.put("key", "blarg");
String s = m.get("key");
当使用 Map 的泛型化版本时，您不再需要将 Map.get() 的结果强制类型转换为 String，因为编译器知道 get() 将返回一个 String 。
在使用泛型的版本中并没有减少键盘录入；实际上，比使用强制类型转换的版本需要做更多键入 。使用泛型只是带来了附加的类型安全 。因为编译器知道关于您将放进 Map 中的键和值的类型的更多信息 ， 所以类型检查从执行时挪到了编译时，这会提高可靠性并加快开发速度 。
向后兼容
在 Java 语言中引入泛型的一个重要目标就是维护向后兼容 。尽管 JDK 5.0 的标准类库中的许多类，比如集合框架，都已经泛型化了，但是使用集合类（比如 HashMap 和 ArrayList）的现有代码将继续不加修改地在 JDK 5.0 中工作 。当然，没有利用泛型的现有代码将不会赢得泛型的类型安全好处 。
二 泛型基础
类型参数
在定义泛型类或声明泛型类的变量时，使用尖括号来指定形式类型参数 。形式类型参数与实际类型参数之间的关系类似于形式方法参数与实际方法参数之间的关系，只是类型参数表示类型，而不是表示值 。
泛型类中的类型参数几乎可以用于任何可以使用类名的地方 。例如，下面是 java.util.Map 接口的定义的摘录：
public interface MapK, V {
public void put(K key, V value);
public V get(K key);
}
Map 接口是由两个类型参数化的 ， 这两个类型是键类型 K 和值类型 V 。（不使用泛型）将会接受或返回 Object 的方法现在在它们的方法签名中使用 K 或 V，指示附加的类型约束位于 Map 的规格说明之下 。
当声明或者实例化一个泛型的对象时，必须指定类型参数的值：
MapString, String map = new HashMapString, String();
注意，在本例中，必须指定两次类型参数 。一次是在声明变量 map 的类型时，另一次是在选择 HashMap 类的参数化以便可以实例化正确类型的一个实例时 。
编译器在遇到一个 MapString, String 类型的变量时，知道 K 和 V 现在被绑定为 String，因此它知道在这样的变量上调用 Map.get() 将会得到 String 类型 。
除了异常类型、枚举或匿名内部类以外，任何类都可以具有类型参数 。
命名类型参数
推荐的命名约定是使用大写的单个字母名称作为类型参数 。这与 C约定有所不同（参阅 附录 A：与 C模板的比较） ， 并反映了大多数泛型类将具有少量类型参数的假定 。对于常见的泛型模式，推荐的名称是：
K —— 键 ， 比如映射的键 。
V —— 值，比如 List 和 Set 的内容，或者 Map 中的值 。
E —— 异常类 。
T —— 泛型 。
泛型不是协变的
关于泛型的混淆，一个常见的来源就是假设它们像数组一样是协变的 。其实它们不是协变的 。ListObject 不是 ListString 的父类型 。
如果 A 扩展 B，那么 A 的数组也是 B 的数组，并且完全可以在需要 B[] 的地方使用 A[]：
Integer[] intArray = new Integer[10];
Number[] numberArray = intArray;
上面的代码是有效的，因为一个 Integer 是 一个 Number，因而一个 In 。
对于集合类的操作的java代码实现的方法//我用集合框架的老大跟子类ArrayList给你写个例子
import java.util.*;
public class CollectionDemo{
public static void main(String[] args){
Collection c = new ArrayList();
//增加
c.add("Java01");
c.add("Java02");
//删除0角标的值
c.remove(0);
//排序为了方便，我把集合框架转成了String[]数组
String[] arr = new String[c.size()];
arr = c.toArray();
Arrays.sort(arr);
//最大值
System.out.println(arr[arr.length-1]);
//因为我是String字符串集合值，没办法比较平均值，可以更改为Interger
}
}
java帮忙写写，几种集合的运用，我是菜鸟！ArrayListInteger list = new ArrayListInteger();
list.addAll(Arrays.asList(17,48,93,75,85));
Integer max = Collections.max(list);
Integer sum = 0;
for (Integer i : list) {
sum= i;
}
//最大值max，和sum
HashSetString set = new HashSetString();
set.addAll(Arrays.asList("a","b","c","d","e"));
for (String s : set) {
//输出Set
System.out.print(s);
System.out.print("\t");
}
HashMapString, String map = new HashMapString, String();
//输入Map
Scanner input = new Scanner(System.in);
for (int i = 0; i5; i) {
System.out.print("键：");
String k = input.nextLine();
System.out.print("值:");
String v = input.nextLine();
map.put(k, v);
}
map.put("a", "a");
map.put("b", "b");
map.put("c", "c");
map.put("d", "d");
map.put("e", "e");
Set keyset = map.keySet();//Map所有键
Collection values = map.values();//Map所有值
//输出Map
for (Object obj : keyset) {
System.out.print(obj);
System.out.println(":");
System.out.println(map.get(obj));
}
java集合的应用代码的介绍就聊到这里吧，感谢你花时间阅读本站内容 ， 更多关于java常用集合、java集合的应用代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：python列表中存放列表去重，python中列表去重

    下一篇：如何正确设置abc服务器？ abc服务器怎么设置