黑马程序员_Map集合练习和工具类以及一些新的知识

---------------------- ASP.Net+Android+IOS开发.Net培训、期待与您交流! ----------------------

Map集合小练习: 

* "fdgavcbsacdfs" 获取该字符串中,每一个字母出现的次数。

 * 要求打印结果是:a(2)b(1)...;
 * 思路:
 * 对于结果的分析发现,字母和次数之间存在着映射的关系。而且这种关系很多。
 * 很多就需要存储,能存储映射关系的容器有数组和Map集合。
 * 关系一方式有序编号吗?没有!
 * 那就是使用Map集合。 又发现可以保证唯一性的一方具备着顺序如 a b c ...
 * 所以可以使用TreeMap集合。
 * 这个集合最终应该存储的是字母和次数的对应关系。 
 * 1,因为操作的是字符串中的字母,所以先将字符串变成字符数组。
 * 2,遍历字符数组,用每一个字母作为键去查Map集合这个表。
 * 如果该字母键不存在,就将该字母作为键 1作为值存储到map集合中。
 * 如果该字母键存在,就将该字母键对应值取出并+1,在将该字母和+1后的值存储到map集合中,
 * 键相同值会覆盖。这样就记录住了该字母的次数.
 * 3,遍历结束,map集合就记录所有字母的出现的次数。oy.
 */

public class MapTest {

public static void main(String[] args) {

String str = "fdg+avAdc  bs5dDa9c-dfs";

String s = getCharCount(str);

System.out.println(s);

}

public static String getCharCount(String str) {

//将字符串变成字符数组 
char[] chs = str.toCharArray();

//定义map集合表。
Map<Character,Integer> map = new TreeMap<Character,Integer>();

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

if(!(chs[i]>='a' && chs[i]<='z' || chs[i]>='A' && chs[i]<='Z'))
// if(!(Character.toLowerCase(chs[i])>='a' && Character.toLowerCase(chs[i])<='z'))
continue;
//将数组中的字母作为键去查map表。
Integer value = map.get(chs[i]);
int count = 1;

//判断值是否为null.
if(value!=null){
count = value+1;
}
map.put(chs[i], count);

}
return mapToString(map); //转化为字符串
}

private static String mapToString(Map<Character, Integer> map) {

StringBuilder sb = new StringBuilder();

Iterator<Character> it = map.keySet().iterator();

while(it.hasNext()){
Character key = it.next();
Integer value = map.get(key);

sb.append(key+"("+value+")");
}

return sb.toString();
}


}

————————————————————————————————

Collections:是集合框架的工具类,里面的方法都是静态的。

static
<T> T
max(Collection<? extends T> coll, Comparator<? super T> comp) 
          根据指定比较器产生的顺序,返回给定 collection 的最大元素。

static
<T> void
sort(List<T> list, Comparator<? super T> c) 
          根据指定比较器产生的顺序对指定列表进行排序。


对一些常用的方法使用演示:
public class CollectionsDemo {
public static void main(String[] args) {
demo_4();
}

public static void demo_4() {
List<String> list = new ArrayList<String>();

list.add("abcde");
list.add("cba");
list.add("zhangsan");
list.add("zhaoliu");
list.add("xiaoqiang");

System.out.println(list);
// Collections.replaceAll(list, "cba", "nba"); // set(indexOf("cba"),"nba");
Collections.shuffle(list);
// Collections.fill(list, "cc");
System.out.println(list);
}

public static void demo_3() {
TreeSet<String> ts = new TreeSet<String>(new Comparator<String>(){


@Override
public int compare(String o1, String o2) {

int temp = o2.compareTo(o1);
return temp;
}

});
TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));

ts.add("abc");
ts.add("hahaha");
ts.add("zzz");
ts.add("aa");
ts.add("cba");

System.out.println(ts);
}

public static void demo_2(){
List<String> list = new ArrayList<String>();

list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
// Collections.sort(list);
System.out.println(list);

// int index = Collections.binarySearch(list, "cba");
// System.out.println("index="+index);

//获取最大值。
String max = Collections.max(list,new ComparatorByLength());
System.out.println("max="+max);
}

public static void demo_1(){

List<String> list = new ArrayList<String>();

list.add("abcde");
list.add("cba");
list.add("aa");
list.add("zzz");
list.add("cba");
list.add("nbaa");
System.out.println(list);

//对list集合进行指定顺序的排序。
// Collections.sort(list);
// mySort(list);
// mySort(list,new ComparatorByLength());
Collections.sort(list,new ComparatorByLength());
System.out.println(list);
}
public static <T> void mySort(List<T> list,Comparator<? super T> comp){     //     Collection.sort的实现代码

for (int i = 0; i < list.size()-1; i++) {

for (int j = i+1; j < list.size(); j++) {

if(comp.compare(list.get(i), list.get(j))>0){

// T temp = list.get(i);
// list.set(i, list.get(j));
// list.set(j, temp);
Collections.swap(list, i, j);

}
}
}
}
}


————————————————————————————————

Arrays:集合框架的工具类。里面的方法都是静态的。

//数组转成集合。
public class ArraysDemo {

public static void main(String[] args) {
demo_2();
}

public static void demo_2() {

/*
* 如果数组中的元素是对象,那么转成集合时,直接将数组中的元素作为集合中的元素进行集合存储。

* 如果数组中的元素是基本类型数值,那么会将该数组作为集合中的元素进行存储。

*/
int[] arr = {31,11,51,61};

List<int[]> list = Arrays.asList(arr);

System.out.println(list);
}

public static void demo_1() {
/*
* 重点:List asList(数组)将数组转成集合。

* 好处:其实可以使用集合的方法操作数组中的元素。
* 注意:数组的长度是固定的,所以对于集合的增删方法是不可以使用的
* 否则会发生UnsupportedOperationException
*/
String[] arr = {"abc","haha","xixi"};

boolean b = myContains(arr, "xixi");
System.out.println("contains:"+b);

List<String> list = Arrays.asList(arr);
boolean b1 = list.contains("xixi");
System.out.println("list contaisn:="+b1);
// list.add("hiahia");//UnsupportedOperationException

System.out.println(list);
}

public static boolean myContains(String[] arr,String key){
for (int i = 0; i < arr.length; i++) {
if(arr[i].equals(key))
return true;
}
return false;
}

//toString的经典实现。
public static String myToString(int[] a){
int iMax = a.length - 1;
if (iMax == -1)
           return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0;  ; i++) {//中间省略条件判断,提高了效率。
            b.append(a[i]);
   if (i == iMax)
    return b.append(']').toString();
           b.append(", ");
        }
}
}


集合转成数组呢”:

public class ToArray {
public static void main(String[] args) {


/*
* 使用的就是Collection接口中的toArray方法。
* 集合转成数组:可以对集合中的元素操作的方法进行限定。不允许对其进行增删。
*/

List<String> list = new ArrayList<String>();
list.add("abc1");
list.add("abc2");
list.add("abc3");

/*
* toArray方法需要传入一个指定类型的数组。
* 长度该如何定义呢?
* 如果长度小于集合的size,那么该方法会创建一个同类型并和集合相同size的数组。
* 如果长度大于集合的size,那么该方法就会使用指定的数组,存储集合中的元素,其他位置默认为null。
* 所以建议,最后长度就指定为,集合的size。
*/
String[] arr = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(arr));
}
}

————————————————————————————————

 foreach语句:
* 格式:
* for(类型  变量   :Collection集合|数组)
* {
*
* }
* 传统for和高级for的区别?
* 传统for可以完成对语句执行很多次,因为可以定义控制循环的增量和条件。

* 高级for是一种简化形式。
* 它必须有被遍历的目标。该目标要是数组,要么是Collection单列集合。

* 对数数组的遍历如果仅仅是获取数组中的元素,可以使用高级for。
* 如果要对数组的角标进行操作建议使用传统for。 

可以使用高级for遍历map集合吗?不能直接用,但是可以将map转成单列的set,就可以用了。

伪代码为:

for(Integer key : map.keySet()){
String value = map.get(key);
System.out.println(key+"::"+value);
}

for(Map.Entry<Integer,String> me : map.entrySet()){
Integer key = me.getKey();
String value = me.getValue();

System.out.println(key+":"+value);
}


 函数的可变参数:
* 其实就是一个数组,但是接收的是数组的元素。
* 自动将这些元素封装成数组。简化了调用者的书写。
* 注意:可变参数类型,必须定义在参数列表的结尾。

public class ParamterDemo {
public static void main(String[] args) {
int sum = newAdd(5,1,4,7,3);
System.out.println("sum="+sum);
int sum1 = newAdd(5,1,2,7,3,9,8,7,6);
System.out.println("sum1="+sum1);

}
public static int newAdd(int a,int...  arr){

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

---------------------- ASP.Net+Android+IOS开发.Net培训、期待与您交流! ----------------------
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值