7.09~7.11学习总结

最新推荐文章于 2024-09-12 08:54:42 发布

成为一颗星星

最新推荐文章于 2024-09-12 08:54:42 发布

阅读量451

点赞数 1

分类专栏： Java自习室文章标签：学习 java

本文链接：https://blog.csdn.net/weixin_74789176/article/details/131626141

版权

Java自习室专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文介绍了Java中的泛型概念，展示了如何使用ArrayList、LinkedList和Vector作为List接口的实现，以及HashMap和TreeMap作为Map接口的实现。讨论了这些集合的特性，如查询效率、增删速度和线程安全性。此外，还提到了Set接口的HashSet和TreeSet，以及迭代器遍历集合的方法。最后，文章提及了Collections工具类的一些常用方法，如排序、反转和查找操作。

摘要由CSDN通过智能技术生成

初识泛型：

class testGeneric
{
    public static void main(String[]args)
    {
        Mycollection<String> MY=new Mycollection<String>();
        MY.set("小饺子",0);
        System.out.println(MY.get(0));//可以转型
    }
}
class Mycollection<E>//规定类型贴标签，无需程序员自子转化
{
    Object[] objs=new Object[5];
    public void set(E obj,int index)
    {
        objs[index]=obj;
    }
    public Object get(int index)
    {
        return objs[index];
    }
}

打印结果：小饺子

容器（集合）里的方法：

import java.util.*;
class TestList
{
    public static void main(String[]args)
    {
        Collection<String>c=new ArrayList<String>();
        System.out.println(c.size());
        System.out.println(c.isEmpty());
        c.add("小饺子");
        c.add("小麻子");
        System.out.println(c.contains("高老二"));
        System.out.println(c);
        c.remove("小饺子");
        System.out.println(c.size());
        c.clear();
        System.out.println(c.size());
        Object[]objs=c.toArray();
        System.out.println(objs  );

    }
}
/*


0
true
false
[小饺子, 小麻子]
1
0
*/

/**
 * Collection接口相关操作方法
 */
import java.util.*;
class Testsss
{
    public static void main(String[]args)
    {
        test02();
    }
    public static void test02()
    {
        Collection<String>list01=new ArrayList<String>();
        list01.add("aa");
        list01.add("bb");
        list01.add("cc");

        List<String>list02=new ArrayList<String>();
        list02.add("aa");
        list02.add("dd");
        list02.add("ee");
        System.out.println("list01"+list01);
        list01.addAll(list02);//将02里面所有元素都放到01后面
        System.out.println("list01"+list01);
        list01.removeAll(list02);//移除01里面和02相同的所有元素；
        System.out.println("list01"+list01);
        list01.retainAll(list02);
        System.out.println("list01"+list01);
        System.out.println(list01.containsAll(list02));//01里是否包含02所有元素，是则true

    }
}



/*
list01[aa, bb, cc]
list01[aa, bb, cc, aa, dd, ee]
list01[bb, cc]
list01[]
false
*/

List是有序（有下标），可重复；

List常用的实现类：ArrayList，LinkedList，Vector


/**
 * List相关实现方法
 */
import java.util.*;
class test000
{
    public static void main(String[]args)
    {
        test03();

    }
    public static void test03()
    {
        List<String>list=new ArrayList<>();
        list.add("aa");
        list.add("cc");
        list.add("dd");
        list.add("ee");
        System.out.println(list);
        list.add(2,"小饺子");//在指定索引处添加相应的值，而对应的数据往后移；
        System.out.println(list);
        list.remove(2);//删除指定元素；
        System.out.println(list);
        list.set(2,"小麻子");//在指定位置将值替换；
        list.get(2);//获得指定元素的地址；
        System.out.println(list.indexOf("小麻子"));//返回这个值的第一次出现的位置，
        System.out.println(list.indexOf("小麻子"));//返回这个值最后一次出现的位置；








    }
}
/*
[aa, cc, dd, ee]
[aa, cc, 小饺子, dd, ee]
[aa, cc, dd, ee]
2
2
*/

ArrayList:查询效率高，增删效率低，线程不安全；数组长度是有限的，但是ArrayList长度不受限制；

LinkedList查询效率低，增删效率高，线程不安全；

Vector查询效率低，增删效率低，线程安全；（使用的最少；）

Map接口：

Map里面的键不可以重复，如果重复，新的将覆盖旧的；

class SxArrayList
{
    public static void main(String[]args)
    {
        Map<Integer,String>m1=new HashMap<>();
        m1.put(1,"小花花");//存入数据
        m1.put(5,"小泥巴");
        System.out.println(m1.isEmpty());//判断是否为空
        System.out.println(m1.containsKey(1));//是否包含键
        System.out.println(m1.containsValue("小麻子"));//是否包含值
        System.out.println(m1.size());//求大小
        System.out.println(m1.get(5));//获得键为5的值
        Map <Integer,String>m2=new HashMap<>();
        m2.put(3,"小麻子");
        m1.putAll(m2);//将m2里面的所有内容都加进m1；
        System.out.println(m1);

    }
}

/*
false
true
false
2
小泥巴
{1=小花花, 3=小麻子, 5=小泥巴}
*/

Java里面规定，两个equals返回相同的对象必须有相同的hashcode

HashMap的扩容问题，当数组长度达到原来数组的0.75的时候，数组会扩容到原来的两倍；

TreeMap方法：

import java.util.*;

class SxArrayList
{
    public static void main(String[]args)
    {
        Map<Integer,String>treemap1=new TreeMap<>();
        treemap1.put(1,"小麻子");
        treemap1.put(4,"小饺子");
        for(Integer key:treemap1.keySet())
        {
            System.out.println(key+"---"+treemap1.get(key));
        }
        Map<emp,String>treemap2=new TreeMap<>();
        treemap2.put(new emp(333,"小麻子",5418),"小麻子爱唱歌");
        treemap2.put(new emp(231,"小饺子",5488),"小饺子爱吃小麻子");
        treemap2.put(new emp(111,"小麻子升级版",54188),"小麻子还是我的er");
        for(emp tem: treemap2.keySet())
        {
            System.out.println(tem+"--"+treemap2.get(tem));
        }
    }
}
class emp implements Comparable<emp>
{
    int id;
    String name;
    double salary;

    public emp(int id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
       return "id"+id+" name:"+name;
    }

    @Override
    public int compareTo(emp o) {
        if(this.salary>o.salary)return 1;
            else if(this.salary<o.salary)return -1;
            else if(this.id>o.id)return 1;
            else if(this.id<o.id)return -1;
            return 0;

    }
}

/*
运行结果：
1---小麻子
4---小饺子
id333 name:小麻子--小麻子爱唱歌
id231 name:小饺子--小饺子爱吃小麻子
id111 name:小麻子升级版--小麻子还是我的er
*/

HashMap：‘线程不安全，效率高，允许key和value为空

TableMap：线程安全，效率低，不允许key和value为为空

Set里面有两个实现，HashSet，TableSet；

没有顺序不可重复：

class SxArrayList
{
    public static void main(String[]args)
    {
        Set<String> set1=new HashSet<>();
        set1.add("小麻子在干嘛");
        set1.add("as");
        set1.add("bb");
        set1.add("小麻子在干嘛");
        System.out.println(set1);
    }
}
/*
[bb, as, 小麻子在干嘛]

*/

class SxArrayList
{
    public static void main(String[]args)
    {
        Set<String>set =new TreeSet<>();
        set.add("200");
        set.add("300");
        set.add("600");
        System.out.println(set);
        Set<cmp>set1=new TreeSet<>();
        set1.add(new cmp(101,"小麻子",54188));
        set1.add(new cmp(1001,"小饺子",14438));
        System.out.println(set1);
    }


}
class cmp implements Comparable<cmp>
{

    int id;
    String name;
    double salary;

    public cmp(int id, String name, double salary) {

        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "id--"+id+"---name--"+name+"--salary--"+salary;
    }

    @Override
    public int compareTo(cmp o) {
        if(o.salary>this.salary)
        {
            return -1;
        }
        else if(o.salary<this.salary)
        {
            return 1;
        }
        else if(o.id<this.id)
        {
            return 1;
        }
        else if(o.id>this.id)
        {
            return -1;
        }


        return 0;
    }
}

迭代器遍历list，set，map

class SxArrayList
{
    public static void main(String[]args)
    {
        listmethod();
        System.out.println("---------");
        setmethod();
        System.out.println("---------");
        mapmethod1();
        System.out.println("---------");
        mapmethod2();



    }
    public static void listmethod()
    {
        List<String>list =new ArrayList<>();
        list.add("小饺子");
        list.add("小麻子");
        for(Iterator<String>iter=list.iterator(); iter.hasNext();)
        {
            String temp=iter.next(); System.out.println(temp);
        }
    }
    public static void setmethod()
    {
        Set<String>set=new HashSet<>();
        set.add("小麻子喜欢小饺子，因为小饺子是爸爸");
        set.add("麻子说的");
        for(Iterator<String>iter1=set.iterator(); iter1.hasNext();)
        {
            String temp= iter1.next();
            System.out.println(temp);
        }

    }
    public static void mapmethod1()
    {
        Map<Integer,String>map=new HashMap<>();
        Set<Map.Entry<Integer,String>>ss=map.entrySet();
        map.put(1,"小麻子");
        map.put(4,"小饺子");

        for(Iterator<Map.Entry<Integer,String>> iter =ss.iterator();iter.hasNext();)
        {
            Map.Entry<Integer,String>temp=iter.next();
            System.out.println(temp.getKey()+"--"+temp.getValue());
        }
    }
    public static void mapmethod2()
    {
        Map<Integer,String>map=new HashMap<>();
        map.put(3,"小麻子");
        map.put(4,"小饺子");
        Set<Integer>ss=map.keySet();
        for(Iterator<Integer>iter=ss.iterator();iter.hasNext(); )
        {
            Integer temp= iter.next();
            System.out.println(temp+"--"+map.get(temp));
        }
    }
}
/*
小饺子
小麻子
---------
小麻子喜欢小饺子，因为小饺子是爸爸
麻子说的
---------
1--小麻子
4--小饺子
---------
3--小麻子
4--小饺子


*/

Collections工具类：

class SxArrayList
{
    public static void main(String[]args)
    {
        List list=new ArrayList<>();
        for(int i=0;i<10;i++)
        {
            list.add("小麻子"+i+"号");
        }
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        Collections.sort(list);
        System.out.println(list);
        System.out.println(Collections.binarySearch(list,"小麻子一号"));
        System.out.println(Collections.binarySearch(list,"小麻子1号"));




    }

}
/*
[小麻子0号, 小麻子1号, 小麻子2号, 小麻子3号, 小麻子4号, 小麻子5号, 小麻子6号, 小麻子7号, 小麻子8号, 小麻子9号]
[小麻子0号, 小麻子2号, 小麻子3号, 小麻子6号, 小麻子1号, 小麻子8号, 小麻子5号, 小麻子4号, 小麻子7号, 小麻子9号]
[小麻子9号, 小麻子7号, 小麻子4号, 小麻子5号, 小麻子8号, 小麻子1号, 小麻子6号, 小麻子3号, 小麻子2号, 小麻子0号]
[小麻子0号, 小麻子1号, 小麻子2号, 小麻子3号, 小麻子4号, 小麻子5号, 小麻子6号, 小麻子7号, 小麻子8号, 小麻子9号]
-11
1


*/

IO流之文件合并。

然后再总结一下最近写的题目：

J - 最大加权矩形

这题过的格外的顺利，显示数据比较小，反正我是四个嵌套循环都没炸，然后用到二维数组的前缀和，也就是两个循环表示二维数组的右下坐标，还有两个就是表示加权矩形的长宽，要注意的是，最里面的两个循环，i1代表的是矩形的长度，所以是在二维数组里面靠j限制的，那个j1同理，不能混了，否则容易错；

#include<stdio.h>
int a[130][130];
int b[130][130];
int main()
{

    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
             scanf("%d",&a[i][j]);

        }


    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            b[i][j]=b[i][j-1]+b[i-1][j]-b[i-1][j-1]+a[i][j];
        }
    }

    int maxx=-1000000000;

    for(int i=1;i<=n;i++)
    {

        for(int j=1;j<=n;j++)
        {
            for(int i1=1;i1<=j;i1++)
            {

                for(int j1=1;j1<=i;j1++)
                {

                    int h=b[i][j]+b[i-j1][j-i1]-b[i][j-i1]-b[i-j1][j];
                    if(h>maxx)maxx=h;


                }
            }

        }
    }

    printf("%d\n",maxx);




}

K - Sum in Binary Tree

这是一个完全二叉树，所以可以根据它的性质每个结点的做儿子的索引为当前节点的2倍，右节点为两倍加1；然后反过来用递归就可以了，注意数据的大小。

#include<stdio.h>
long long add(long long n)
{
    if(n==1)return 1;

    return add(n/2)+n;

}

int main()
{

    int t;
    scanf("%d",&t);
    while(t--)
    {
        long long  n;
        scanf("%lld",&n);
        printf("%llu\n",add(n));



    }
    return 0;

}

L - A+B Problem（高精）

大数加法，先将数据输入为字符，然后将字符放进数组里面，找出两个加数的数组的短一点长度的数组，然后全体往后移较长数组-较短数组的位数，以保证两个数的加减是在同一位，记得加减的时候先转变成数字，如果两个数加起来是大于十，就用一个数存起来，便于对下一个加一，然后有一个小技巧，如果数字要变成字符存进去，先加上一个48然后别忘了强制转换，后来要倒序相加，以防前面的位数不够存，最后倒叙读取就行了；

#include<stdio.h>
#include<string.h>
char c[2000];
int dashuadd(char a[],char b[])
{
    int l1=strlen(a);
    int l2=strlen(b);
    int h=0;
    int z=l1>l2?l1:l2;
    int count1=0;
    if(l1>l2)
    {
        for(int i=strlen(b)-1; i>=0; i--)
        {
            b[i+z-l2]=b[i];
        }
        for(int i=0; i<z-l2; i++)
        {
            b[i]='0';
        }

    }

    else
    {
        for(int i=strlen(a)-1; i>=0; i--)
        {
            a[i+z-l1]=a[i];
        }
        for(int i=0; i<z-l1; i++)
        {
            a[i]='0';
        }
    }


    int i=z-1;
    for(int j=z-1;i>=0&&j>=0;i--,j--)
    {


            int m=0;
            if(!h)
             m=(a[i]-'0')+(b[j]-'0');
            else
             {m=(a[i]-'0')+(b[j]-'0')+1;h--;}


            if(m>=10){h++;m-=10;}
            c[count1++]=(char)(m+48);
            if(i==0&&h==1)c[count1++]='1';


    }
    return count1;



}
int main()
{
    char a[1050],b[1050];
    scanf("%s",a);
    scanf("%s",b);
    int k=dashuadd(a,b);
    for(int i=k-1; i>=0; i--)
    {
        printf("%c",c[i]);
    }

}

A - I Hate 1111

考试的时候写了快一个小时都没写出来就放弃了，方向错了，我一直在找10和1凑出来的规律，其实最容易找的现在发现还是11和111，可以发现的是如果由这两个个组成的话，就可以满足题意了；如果算的再仔细点可以发现系数不超过11 ，当然，大一点也不会爆，要注意，不要让对11取余的为负数；

#include<stdio.h>
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int i;
        int x;
        scanf("%d",&x);
        int flag=0;
       for( i=0;i<=11;i++)
       {
           if(x-111*i<0)break;
           if((x-111*i)%11==0)
           {
               flag=1;
               printf("YES\n");break;
           }
           
       }
       if(flag==0)
       printf("NO\n");

    }
    return 0;

}

B - Pashmak and Garden

这个题刚开始想了很久，把情况想复杂了，看到了它的范围就知道是不会越界的，而且有多种情况，可以选择一种作为自己的，比如我选择的是下面，如果x，y有一个是相等的，就可以判断他们是那个相等，不需要判断都相等，题目上限制了，是x想的的话，就将3，4点放在这两个点的左边或者右边，如果是y的话，就放在上面或者下面，如果是两个都不相等的话，就判断一下，它们的x12和y12之差是否相等，如果不相等的的话就是没有-1，如果相等，这时候根本不需要判断他们是否越界而是判断，因为不管怎么样，3，4的两个坐标来自两个不同的，也就是1，2，至于哪个是哪个，都行；

#include<stdio.h>
#include<math.h>
int main()
{

    int x1,y1,x2,y2;int x3,y3,x4,y4;
    scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
    if((x1!=x2&&y1!=y2)||(x1!=x2&&y1!=y2))
    {
        if(abs(x1-x2)!=abs(y1-y2)) printf("-1\n");

        else
        {
            printf("%d %d %d %d",x1,y2,x2,y1);
        }

    }


    else
    {
        if(y1==y2)
        {
        int x=abs(x2-x1);
        x3=x1;x4=x2;
        y3=y1-x;y4=y2-x;
        printf("%d %d %d %d\n",x3,y3,x4,y4);


        }
        if(x1==x2)
        {
        int x=abs(y2-y1);
        x3=x4=x2-x;
        y3=y1;y4=y2;
        printf("%d %d %d %d\n",x3,y3,x4,y4);

        }
    }
}

最最后，心灵鸡汤来咯：

你呀，总是看到自己身上的小小瑕疵，然后失落，然后自卑，可你别忘了，你也闪闪发光，也温柔、也可爱、也在努力并一定会成为更好的人，所以请放宽心，你一定会一步步靠近更喜欢的自己！