7.09~7.11学习总结
初识泛型：
class testGeneric
{
public static void main(String[]args)
{
Mycollection MY=new Mycollection();
MY.set("小饺子",0);
System.out.println(MY.get(0));//可以转型
}
}
class Mycollection//规定类型贴标签，无需程序员自子转化
{
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)
{
Collectionc=new ArrayList();
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()
{
Collectionlist01=new ArrayList();
list01.add("aa");
list01.add("bb");
list01.add("cc");
Listlist02=new ArrayList();
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()
{
Listlist=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)
{
Mapm1=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 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)
{
Maptreemap1=new TreeMap<>();
treemap1.put(1,"小麻子");
treemap1.put(4,"小饺子");
for(Integer key:treemap1.keySet())
{
System.out.println(key+"---"+treemap1.get(key));
}
Maptreemap2=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
{
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.salaryo.id)return 1;
else if(this.id HashMap：‘线程不安全，效率高，允许key和value为空
TableMap：线程安全，效率低，不允许key和value为为空
Set里面有两个实现，HashSet，TableSet；
没有顺序不可重复：
class SxArrayList
{
public static void main(String[]args)
{
Set 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)
{
Setset =new TreeSet<>();
set.add("200");
set.add("300");
set.add("600");
System.out.println(set);
Setset1=new TreeSet<>();
set1.add(new cmp(101,"小麻子",54188));
set1.add(new cmp(1001,"小饺子",14438));
System.out.println(set1);
}
}
class cmp implements Comparable
{
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.salarythis.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()
{
Listlist =new ArrayList<>();
list.add("小饺子");
list.add("小麻子");
for(Iteratoriter=list.iterator(); iter.hasNext();)
{
String temp=iter.next(); System.out.println(temp);
}
}
public static void setmethod()
{
Setset=new HashSet<>();
set.add("小麻子喜欢小饺子，因为小饺子是爸爸");
set.add("麻子说的");
for(Iteratoriter1=set.iterator(); iter1.hasNext();)
{
String temp= iter1.next();
System.out.println(temp);
}
}
public static void mapmethod1()
{
Mapmap=new HashMap<>();
Set>ss=map.entrySet();
map.put(1,"小麻子");
map.put(4,"小饺子");
for(Iterator> iter =ss.iterator();iter.hasNext();)
{
Map.Entrytemp=iter.next();
System.out.println(temp.getKey()+"--"+temp.getValue());
}
}
public static void mapmethod2()
{
Mapmap=new HashMap<>();
map.put(3,"小麻子");
map.put(4,"小饺子");
Setss=map.keySet();
for(Iteratoriter=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
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
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
#include
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=0; i--)
{
a[i+z-l1]=a[i];
}
for(int i=0; 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
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
#include
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);
}
}
} 最最后，心灵鸡汤来咯：
你呀 ，总是看到自己身上的小小瑕疵 ，然后失落 ，然后自卑， 可你别忘了 ，你也闪闪发光， 也温柔 、也可爱、 也在努力并一定会成为更好的人 ，所以请放宽心 ，你一定会一步步靠近更喜欢的自己！