C++与Java的API对比（集合操作等方面）

转载请注明出处(～￣▽￣)～

个人第一篇博客，觉得不错就点个“推荐”吧 φ(゜▽゜*)♪



虽然自己是先学的C++，再学的Java，但是相对而言，自己写Java比写C++要相对多一些。参加算法竞赛时起初也是更加喜欢使用Java（毕竟没有奇奇怪怪的段错误），但是愈发感觉国内算法竞赛（其实哪里都是）对C++以外的语言还是不太友好的，所以在此做一个简单的总结，把一些常用操作做一个对比。（以方便被打压的Java选手转型C++）

一维数组初始化

Java

int[] arr = new int[len]; // len代表长度，在下文可能会有不少这类的默认变量
int[] arr = {1,2,3};
int[] arr = new int[]{1,2,3};

C++

int *pia = new int[10]; // 每个元素都没有初始化
int *pia2 = new int[10] ();  // 每个元素初始化为0
string *psa = new string[10];  // 每个元素调用默认构造函数初始化
string *psa = new string[10]();  // 每个元素调用默认构造函数初始化
char *cp = new char[len];
delete [] cp;
int value[100] = {1,2}; // value[0]和value[1]的值分别为1和2，而没有定义的value[i>1]则初始化为0

二维数组初始化

Java

//Java的二维数组不一定需要是一个矩阵
int[][] arr = new int[len][len];
String[][] arr = new String[len][len]; //非基本类型还需对每个元素单独进行new

C++

int value[9][9]; // value[i][j]的值不定，没有初始化
int value[9][9] = {{1,1},{2}}； //value[0][0,1]和value[1][0]的值初始化，其他初始化为0
int (*value)[n] = new int[m][n];
delete []value; // n必须为常量，调用直观。未初始化
int** value = new int* [m];
for(int i=0;i<m;++i) value[i] = new int[n];
for(int i=0;i<m;++i) delete []value[i];
delete []value; // 多次析构，存储麻烦，未初始化

多维数组初始化：

Java

同于二维

C++

int arr[1][2][3];
int arr[1][2][3] = {{1}};

数组初始化(使用函数)

Java

Arrays.fill(arr,0);

C++

memset(arr,0,sizeof(arr))   //memset用于对连续内存进行初始化，更快
fill(arr,arr+len,0)

集合类及操作

列表

Java

List<Integer> l = new ArrayList<Integer>();
List<Integer> l = new LinkedList<Integer>();
l.add(e);
l.add(ind,e);
l.addAll(ll);
l.get(ind);
l.indexOf(e);
l.isEmpty();
l.remove(ind);
l.set(ind,e);
l.size();
l.clear();

C++

vector<int> a ;               //声明一个int型向量a
vector<int> a(10) ;           //声明一个初始大小为10的向量
vector<int> a(10, 1) ;      //声明一个初始大小为10且初始值都为1的向量
vector<int> b(a) ;            //声明并用向量a初始化向量b
vector<int> b(a.begin(), a.begin()+3) ;    //将a向量中从第0个到第2个(共3个)作为向量b的初始值
vector<vector<int>> vec(row,vector<int>(col,0));
int n[] = {1, 2, 3, 4, 5} ;
vector<int> a(n, n+5) ;              //将数组n的前5个元素作为向量a的初值
vector<int> a(&n[1], &n[4]) ;        //将n[1] - n[4]范围内的元素作为向量a的初值
a.emplace_back(e);// emplace_back为C++ 11的函数，若不支持可以使用push_back
a.emplace(a.begin()+4, e);
dest.insert(dest.end(), src.begin(), src.end());
a[ind];
find(a.begin( ), a.end( ), e ); //没找到则返回a.end()
a.empty();
a.erase(ind);
a.erase(first,last);
a[ind]=e;
a.size();
a.clear();

集合

Java

Set<Integer> s = new HashSet<Integer>();
Set<Integer> s = new TreeSet<Integer>();
s.add(e);
s.addAll(ss);
s.contains(e);
s.isEmpty();
s.remove(e);
s.size();
s.clear();

C++

unordered_set<int> s;
unordered_set<string> myset = {"yellow","green","blue"};
s.insert(e);    //也可范围插入
s.find(e); //没找到则返回s.end()
s.empty();
s.earse(e);
s.size();
s.clear();

Map

Java

Map<Integer,Integer> map = new HashMap<>();
map.put(1,1);
map.containsKey(k);
map.containsValue(v);
map.get(k);
map.isEmpty();
map.remove(k);
map.size();

C++

unordered_map<string,double> map;
pair<string,double> myshopping ("baking powder",0.3);
//pair只有两个值，而tuple可以支持多个值
//tuple<int,int,int> t(1,1,1);
//get<ind>(t);
//make_tuple<int,int,int>(1,1,1);
map.insert (myshopping);                        // 复制插入
map.insert (make_pair<string,double>("eggs",6.0)); // 移动插入
map.insert (mypantry.begin(), mypantry.end());  // 范围插入
map.insert ({{"sugar",0.8},{"salt",0.1}});    // 初始化数组插入(可以用二维一次插入多个元素，也可以用一维插入一个元素)
map["coffee"] = 10.0;  //数组形式插入
map.count(k);   //为1则是有，为0则是没有
map.find(k);    //返回map.end()则是没有
map.empty();
map.earse(k);
map.size();

队列

Java

Queue<Integer> q = new LinkedList<>();
q.add(e);
q.poll();
q.peek();
q.isEmpty();
q.size();

C++

queue<string> q;
q.emplace(e);
q.front();
q.pop();
q.empty();
q.size();

双向队列

Java

Deque<Integer> q = new ArrayDeque<>();
q.addFirst(e);
q.addLast(e);
q.getFirst(e);
q.getLast(e);
q.peekFirst(e);
q.peekLast(e);
q.removeFirst(e);
q.removeLast(e);
q.isEmpty();
q.size();

C++

deque<int> q;
q.emplace_front(e);
q.emplace_back(e);
q.pop_front(e);
q.pop_back(e);
q.assign(beg,end);  //区间赋值
q.empty();
q.size();

栈

Java

推荐使用Deque

C++

stack<int> s;
s.empty();         //如果栈为空则返回true, 否则返回false;
s.size();          //返回栈中元素的个数
s.top();           //返回栈顶元素, 但不删除该元素
s.pop();           //弹出栈顶元素, 但不返回其值
s.emplce();          //将元素压入栈顶

堆

Java

Queue<Integer> q = new PriorityQueue<>();
//其余方法同于队列

C++

//升序队列
priority_queue <int,vector<int>,greater<int> > q;
//降序队列
priority_queue <int,vector<int>,less<int> >q;
//对于基础类型 默认是大顶堆
priority_queue<int> q;
//除了q.top()才是访问队列首元素，其他方法保持与队列一致

类型转换

Java

//基本类型转化为字符串
String.valueOf()
//字符串转基本类型
XXX.parseXXX()

C++

//基本类型转化为字符串
to_string (val);
std::stringstream ssTemp;
ssTemp<<5;
std::string strDst=ssTemp.str();
//字符串转基本类型
stoi()、stol()、stoll()、atof()
int a = 0;
char *strData = "123";
stringstream stream(strData );
stream>>a;

文件操作与重定向

Java

//保存最原始的输入输出流
InputStream in = System.in;
PrintStream out = System.out;
System.setIn(new FileInputStream("in.txt"));
System.setOut(new PrintStream("out.txt"));
BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt"),"UTF-8"));
PrintWriter pw = new PrintWriter("text.txt");

C++

ifstream fin("test.dat");
ofstream fout("test.dat");
streambuf * backup;
ifstream fin;
ofstream fout;
fout.open("data.txt");
backup = cout.rdbuf();
cout.rdbuf(fout.rdbuf());
cout.rdbuf(backup);

如有错误，还望不吝指出。

转载请注明出处(～￣▽￣)～