Ctiter是Hibernate无语句面向对象查询
public void getVoid(){
Configuration configure = new Configuration().configure();
SessionFactory sessionFactory = configure.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
//====编写实体对象===============
/**
* 查询所有的查询对象
*/
Criteria createCriteria = session.createCriteria(User.class);
List<User> list = createCriteria.list();
System.out.println("list:"+list);
//查询单个对象
//User uniqueResult = (User)createCriteria.uniqueResult();
//===================
tx.commit();
session.close();
}
/***
* Restrictions 条件参数的设置
* > --> gt
* >= --> ge
* < --> lt
* <= --> le
* == --> eq
* != --> ne
* in --> in
* between and --> between
* like --> like
* is not null --> isNotNull
* is null --> inNull
* or --> or
* and --> and
*/
//====编写实体对象===============
/**
* 查询所有的查询对象
*/
Criteria createCriteria = session.createCriteria(User.class);
//添加查询的参数
createCriteria.add(Restrictions.eq("id", 1l));
List list = createCriteria.list()
/**
* 设置分页的信息
*/
Criteria createCriteria = session.createCriteria(User.class);
createCriteria.setFirstResult(1);//开始
createCriteria.setMaxResults(3);//多少条数据
List list = createCriteria.list();
* 设查询聚合行数==》总行数
*/
Criteria createCriteria = session.createCriteria(User.class);
//
createCriteria.setProjection(Projections.rowCount());
Long uniqueResult = (Long)createCriteria.uniqueResult();
Criteria createCriteria = openSession.createCriteria(User.class);
createCriteria.addOrder(Order.desc("id"));
List<User> list = createCriteria.list();
for (User user : list) {
System.out.println(user);
}
public void getVoid04(){
//创建离线的查询
DetachedCriteria forClass = DetachedCriteria.forClass(User.class);
//拼装条件进行查询
forClass.add(Restrictions.idEq(3l));
//创建Session
Configuration configure = new Configuration().configure();
SessionFactory sessionFactory = configure.buildSessionFactory();
Session openSession = sessionFactory.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//------------------
//进行组装session条件
Criteria executableCriteria = forClass.getExecutableCriteria(openSession);
List list = executableCriteria.list();
for (Object object : list) {
System.out.println(object);
}
//------------------
beginTransaction.commit();
openSession.close();
}
//===原生的SQL语句查询===============
String sql="select * from user";
//创建SQL的查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
List<Object[]> list = createSQLQuery.list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
/* 查询单个
* createSQLQuery.uniqueResult();*/
//===================
//===原生的SQL语句查询===============
String sql="select * from user";
//创建SQL的查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
// 将结果集封装到结果对象中
createSQLQuery.addEntity(User.class);
//得到结果
List<User> list = createSQLQuery.list();
System.out.println(list);
//===原生的SQL语句查询===============
String sql="select * from user where id =?";
//创建SQL的查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
//设置参数
createSQLQuery.setParameter(0,1l);
createSQLQuery.addEntity(User.class);
//得到结果
List<User> list = createSQLQuery.list();
System.out.println(list);
//===原生的SQL语句查询===============
String sql="select * from user limit ?,?";
//创建SQL的查询对象
SQLQuery createSQLQuery = session.createSQLQuery(sql);
//设置参数
createSQLQuery.setParameter(0, 1);
createSQLQuery.setParameter(1, 3);
createSQLQuery.addEntity(User.class);
//得到结果
List<User> list = createSQLQuery.list();
1.客户实体类
public class Customer {
private Long c_id;
private String c_name;
//使用Set集合表达一对多的关系
private Set<Orders> orders=new HashSet<Orders>();
//对应的get set 方法
}
2.订单实体类
public class Orders {
private Long o_id;
private String o_name;
//表达多对一的的关系
private Customer customer;
//对应的get set 方法
}
<mapping resource="com/hibernate01/dem02/bean/Customer.hbm.xml" />
<mapping resource="com/hibernate01/dem02/bean/Orders.hbm.xml" />
<hibernate-mapping >
<class name="com.hibernate01.dem02.bean.Customer" >
<id name="c_id" column="c_id">
<generator class="native"></generator>
</id>
<property name="c_name" column="c_name" > </property>
<!--集合;一对多关系的配置 -->
<!--name 集合的属性名
cascade:级联操作如(保存客户时把客户的订单也同时保存)
save-update:级联保存更新
delete:级联删除
all:(save-update+delete)
级联操作:本质,就是简化操作
inverse:配置关联维护关系(反转)
true:当前配置的类不维护关系
false:默认值 当前配置类维护
关联维护本质:提高关系维护的性能
-->
<set name="orders" cascade="" inverse="" >
<!--column:对应的是外键关系 (必须一致)
-->
<key column="o_c_id" ></key>
<!--one-to-many 指向的一对多
class:与本类关联的对象完整类名
-->
<one-to-many class="com.hibernate01.dem02.bean.Orders" />
</set>
</class>
</hibernate-mapping>
<hibernate-mapping>
<class name="com.hibernate01.dem02.bean.Orders">
<id name="o_id" column="o_id">
<generator class="native" ></generator>
</id>
<property name="o_name" column="o_name" ></property>
<!-- 多对一的配置
name:配置对象的属性名
column:对应的是外键关系(必须一致)
class:与本类关联的对象完整类名
cascade:级联操作如(保存客户是把客户的订单也同时保存)
save-update:级联保存更新
delete:级联删除
all:(save-update+delete)
-->
<many-to-one cascade="" name="customer" column="o_c_id" class="com.hibernate01.dem02.bean.Customer" ></many-to-one>
</class>
</hibernate-mapping>
测试
**
* 多对一| 一对多
* 保存 客户意见客户下的订单
*/
@Test
public void getVoid(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//-------操作----------
Customer customer = new Customer();
customer.setC_name("小张");
Orders order = new Orders();
order.setO_name("西瓜");
Orders order1 = new Orders();
order1.setO_name("苹果");
/**
* 表示一对多,客户下有多个订单
*/
customer.getOrders().add(order);
customer.getOrders().add(order1);
/**
* 表示多对的多,订单属于那个客户
*/
order1.setCustomer(customer);
order.setCustomer(customer);
openSession.save(customer);
/*
* 如这两行代码不写,需要配置级联操作
* save-update:级联保存更新
* openSession.save(order);
openSession.save(order1);*/
//---------------------
beginTransaction.commit();
openSession.close();
}
//-------操作----------
Customer customer = openSession.get(Customer.class, 1L);
Orders order = new Orders();
order.setO_name("葡萄");
Orders order1 = new Orders();
order1.setO_name("香蕉");
/**
* 表示一对多,客户下有多个订单
*/
customer.getOrders().add(order);
customer.getOrders().add(order1);
/**
* 表示多对的多,订单属于那个客户
*/
order1.setCustomer(customer);
order.setCustomer(customer);
openSession.save(order);
openSession.save(order1);
Customer customer = openSession.get(Customer.class, 1L);
Orders orders = openSession.get(Orders.class, 1L);
customer.getOrders().remove(orders);
orders.setCustomer(null)
多对一配置
Name:配置对象的属性名
Column:对应的是外建关系(必须一致)
Class:与本类关联的对象完整类名
Cascade:级联操作(保存客户时把客户的订单同时保存)
save-update:级联保存更新
delete:级联删除
all:(save-update+delete)
<many-to-one cascade="" name="customer" column="o_c_id" class="com.hibernate01.dem02.bean.Customer" ></many-to-one>
/**
* 多对一| 一对多
* 保存 客户意见客户下的订单
*/
@Test
public void getVoid(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//-------操作----------
Customer customer = new Customer();
customer.setC_name("小张");
Orders order = new Orders();
order.setO_name("西瓜");
Orders order1 = new Orders();
order1.setO_name("苹果");
/**
* 表示一对多,客户下有多个订单
* 如果客户放弃维护,代码可以不用写
*/
customer.getOrders().add(order);
customer.getOrders().add(order1);
/**
* 表示多对的多,订单属于那个客户
*/
order1.setCustomer(customer);
order.setCustomer(customer);
openSession.save(customer);
openSession.save(order);
openSession.save(order1);
//---------------------
openSession.close();
}
inverse:配置关联维护关系(反转)
true:当前配置的类不维护关系
false:默认值 当前配置类维护
<set name="orders" inverse="true" >
<!--column:对应的是外键关系 (必须一致)
-->
<key column="o_c_id" ></key>
<!--one-to-many 指向的一对多
class:与本类关联的对象完整类名
-->
<one-to-many class="com.hibernate01.dem02.bean.Orders" />
</set>
2.注意—放弃维护方
1.添加:
/**
* 表示一对多,客户下有多个订单
* 如果客户放弃维护,代码可以不用写
*/
customer.getOrders().add(order);
customer.getOrders().add(order1);
2.删除
/**
* 如:Customer设置了,不进行维护关系
* 在这里是不能删除的
* 如需要删除:
* 方式一: 开启 cascade="delete"
* 方式二: 开始维护 inverse="false"
* */
Customer customer = openSession.get(Customer.class, 1L);
openSession.delete(customer);
删除的配置
<set name="orders" inverse="true" cascade="delete" >
<!-- <set name="orders" inverse="false" > -->
<!--column:对应的是外键关系 (必须一致)
-->
<key column="o_c_id" ></key>
<!--one-to-many 指向的一对多
class:与本类关联的对象完整类名
-->
<one-to-many class="com.hibernate01.dem02.bean.Orders" />
</set>
多对多的表达关系
name:集合对应的属性名
table:中间表名
<set name="student" table="student_teacher">
<!--column:外键 指定别人<引用我>的ID名 -->
<key column="t_id"></key>
<!--class:指定那个类是多对多的关系
column:外键<我引用>别人的外键
-->
<many-to-many class="com.hibernate01.dem02.bean.Student" column="s_id"></many-to-many>
</set>
1.1非业务方不进行保存
public void getVoid(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//-------操作----------
Teacher teacher = new Teacher();
teacher.setT_name("陈老师");
Teacher teacher1 = new Teacher();
teacher1.setT_name("张老师");
Student student = new Student();
student.setS_name("张三同学");
Student student2 = new Student();
student2.setS_name("张三同学");
/**
* 对象的关系设置
*/
//teacet的对应关系
/* 非业务方不进行保存
* teacher1.getStudent().add(student);
teacher1.getStudent().add(student2);
teacher.getStudent().add(student);
teacher.getStudent().add(student2);*/
//student的对应关系
student.getTeacher().add(teacher);
student.getTeacher().add(teacher1);
student2.getTeacher().add(teacher);
student2.getTeacher().add(teacher1);
/**
* 保存
*/
openSession.save(teacher);
openSession.save(teacher1);
openSession.save(student);
openSession.save(student2);
//---------------------
beginTransaction.commit();
openSession.close();
}
1.2.非业务方放弃维护关系
<!-- 使用inverse属性
true: 放弃维护外键关系
false(默认值):维护关系
结论: 将来在开发中,如果遇到多对多关系.一定要选择一方放弃维护关系.
一般谁来放弃要看业务方向.
业务方向维护角色. 非业务方向不需要维护关系.放弃维护
-->
<set name="student" table="student_teacher" inverse="true">
<!--column:外键 指定别人<引用我>的ID名 -->
<key column="t_id"></key>
<!--class:指定那个类是多对多的关系
column:外键<我引用>别人的外键
-->
<many-to-many class="com.hibernate01.dem02.bean.Student" column="s_id"></many-to-many>
</set>
/**
* 给学生添加老师
*/
@Test
public void getVoid1(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//-------操作----------
//获取到学生
Student student = openSession.get(Student.class, 1l);
//创建老师
Teacher teacher = new Teacher();
teacher.setT_name("王老师");
//添加老师
student.getTeacher().add(teacher);
//将瞬时状态转换为持久状态
openSession.save(teacher);
//---------------------
beginTransaction.commit();
openSession.close();
}
<!--多对多的表达关系
name:集合对应的属性名
table:中间表名
cascade:级联操作如
save-update:级联保存更新
delete:级联删除(风险大特别是多对多的时,不建议使用)
all:(save-update+delete)
结论: cascade简化代码书写.该属性使不使用无所谓. 建议要用只用save-update.
-->
<set name="teacher" table="student_teacher" cascade="save-update">
<!--column:外键 指定别人<引用我>的ID名 -->
<key column="s_id"></key>
<!--class:指定那个类是多对多的关系
column:外键<我引用>别人的外键
-->
<many-to-many class="com.hibernate01.dem02.bean.Teacher" column="t_id"></many-to-many>
</set>
public void getVoid1(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
Student student = openSession.get(Student.class, 1l);
Teacher teacher = new Teacher();
teacher.setT_name("王老师");
student.getTeacher().add(teacher);
//---------------------
beginTransaction.commit();
openSession.close();
}
/**
* 为学生,解除老师
*/
@Test
public void getVoid2(){
Session openSession = HibernateUtils.openSession();
Transaction beginTransaction = openSession.beginTransaction();
Student student = openSession.get(Student.class, 1l);
Teacher teacher = openSession.get(Teacher.class, 1l);
Teacher teacher2 = openSession.get(Teacher.class, 2l);
student.getTeacher().remove(teacher);
student.getTeacher().remove(teacher2);
//---------------------
beginTransaction.commit();
openSession.close();
}
2.实体类
public class Orders {
private Long o_id;
private String o_name;
//表达多对一的的关系
private Customer customer;
//对应的 get set方法
}
public class Customer {
private Long c_id;
private String c_name;
//使用Set集合表达一对多的关系
private Set<Orders> orders=new HashSet<Orders>();
//对应的get set 方法
}
2.回顾原生SQL语句多表查询
1.交叉连接-笛卡尔乘积
Select * from 表名1,表名2
2.内连接
1.隐士连接
Select * from 表名1,表名2 where 表名1.id=表名2.id
2.显示内连接
Select * from 表名1 inner join 表名2 on 表名.id=表名2.id
Select * from 表名1 left jion 表名2 表名2 on 表名.id=表名2.id
Select * from 表名1 right jion 表名2 表名2 on 表名.id=表名2.id
3.HSQL的多表查询
1.内连接
1.平常内连接:将连接的两端对象分别返回放置数组中
public void getVoid01(){
Configuration configure = new Configuration().configure();
SessionFactory sessionFactory = configure.buildSessionFactory();
Session openSession = sessionFactory.openSession();
Transaction beginTransaction = openSession.beginTransaction();
//------------
String hql="from Customer c inner join c.orders";
Query createQuery = openSession.createQuery(hql);
List<Object[]> list = createQuery.list();
for (Object[] object : list) {
System.out.println(Arrays.toString(object));
}
//------------
beginTransaction.commit();
openSession.close();
}
String hql="from Customer c inner join fetch c.orders";
Query createQuery = openSession.createQuery(hql);
List<Customer> list = createQuery.list();
for (Customer object : list) {
System.out.println(object);
}
String hql="from Customer c left join c.orders";
Query createQuery = openSession.createQuery(hql);
List<Object[]> list = createQuery.list();
for (Object[] object : list) {
System.out.println(Arrays.toString(object));
}
String hql="from Customer c right join c.orders";
Query createQuery = openSession.createQuery(hql);
List<Object[]> list = createQuery.list();
for (Object[] object : list) {
System.out.println(Arrays.toString(object));
}}
Customer customer = openSession.get(Customer.class,1l);
System.out.println(customer);
2.使用load方法加载
1.(默认)是执行时,不发生SQL语句,返回一个对象,使用该对象时才执行SQL查询
2.延迟加载:只是获得对象没有使用不会查询,在使用的时候进行查询
Customer customer = openSession.load(Customer.class,1l);
System.out.println(customer);
2.1延迟加载策略
<hibernate-mapping >
<class name="com.hibernate01.dem02.bean.Customer" lazy="true" >
</class>
</hibernate-mapping >
3.赖加载流程
3.1lazy=true
查询时,会返回一个代理对象,会在使用属性时,根据关联session查询数据库,加载数据
3.2 lazy=false(和get没区别,调用立即加载数据)
直接返回对象
3.3注意:使用懒加载时,调用数据加载数据必须保证session的开启
Customer customer = openSession.get(Customer.class,1l);
//关联级别
Set<Orders> orders = customer.getOrders();
1.0:加载的策略
<hibernate-mapping >
<class name="com.hibernate01.dem02.bean.Customer" lazy="true" >
<!--
lazy:延迟加载
|-true:(默认)延迟加载
|-false:立即加载
|-extra:极其懒惰
fetch:抓取策略.使用什么样的SQL语句加载集合数据
|-select:(默认)单表查询加载
|-join:使用多表查询加载集合
|-subselect:使用子查询加载集合
-->
<set name="orders" lazy="true" fetch="select">
<key column="o_c_id" ></key>
<one-to-many class="com.hibernate01.dem02.bean.Orders" />
</set>
</class>
</hibernate-mapping>
1.1:lazy=true && fetch=select(默认)
1.2:lazy=false && fetch=select
执行44行时,还没有使用集合就会加载集合数据
1.3:lazy=extra && fetch=select
极其懒惰与懒加载基本一致,如获得集合的size,只查询集合的size
1.4:fetch=select
1.5:lazy=true && fetch=subselect
String Hsql="FROM Customer";
Query createQuery = openSession.createQuery(Hsql);
List<Customer> list = createQuery.list();
for (Customer customer : list) {
System.out.println(customer);
System.out.println(customer.getOrders().size());
System.out.println(customer.getOrders());
}
注意:执行45行代码则使用的子查询,与懒加载
1.6:lazy=false && fetch=subselect
1.7;lazy=extra && fetch=subselect
2.属性关联策略
<hibernate-mapping>
<class name="com.hibernate01.dem02.bean.Orders">
<!--
lazy:延迟加载
|-false:立即加载
|-proxy:由该类属性类级别的加载策略 (lazy)进行决定
fetch:抓取策略.使用什么样的SQL语句加载数据
|-select:(默认)单表查询加载
|-join:使用多表查询加载集合
-->
<many-to-one lazy="proxy" fetch="join" name="customer" column="o_c_id" class="com.hibernate01.dem02.bean.Customer" ></many-to-one>
</class>
</hibernate-mapping>
2.0:加载策略
Orders orders = openSession.get(Orders.class, 1l);
Customer customer = orders.getCustomer();
System.out.println(customer);
2.1:fetch=jion
3.总结
1.为了提高fetch应当选择select:lazy应当选择true(使用默认值)
2.no-session(session关闭)
1.过大session的作用使用Filter拦截器进行扩展
4.使用批量加载
<hibernate-mapping >
<class name="com.hibernate01.dem02.bean.Customer" >
<!--batch-size:表示每次加载多少条数据-->
<set name="orders" batch-size="3">
<key column="o_c_id" ></key>
<one-to-many class="com.hibernate01.dem02.bean.Orders" />
</set>
</class>
</hibernate-mapping>
在执行44行代码时,不会执行多个sql语句
文章浏览阅读202次。将整数字符串转换成整数值 给定一个字符串str,如果str符合日常书写的规范,并属于32位整数的范围,返回str所代表的整数值,否则返回0。如 023, A13, 2147483648,均返回0。 【解题思路】 定义四个变量,flag表示正负,res表示结果,minq表示最小值除以10的商,minr表示最小值除以10 的余数。因为最小值是 -2147483..._根据字符串计算出整数值
文章浏览阅读1.1w次,点赞3次,收藏13次。optimize table table_name1. 问题描述在使用mysql的时候有时候,可能会发现尽管一张表删除了许多数据,但是这张表表的数据文件和索引文件却奇怪的没有变小。这是因为mysql在删除数据(特别是有Text和BLOB)的时候,会留下许多的数据空洞/碎片,这些空洞会占据原来数据的空间,所以文件的大小没有改变。这些空洞在以后插入数据的时候可能会被再度利用起来,当然也有可能一直存在。这种空洞不仅额外增加了存储代价,同时也因为数据碎片化降低了表的扫描效率。2. 使用场景如果您已经删除._table does not support optimize, doing recreate + analyze instead
文章浏览阅读293次。文章目录0. 前言1. 完全背包+求方案数0. 前言相关:[背包] 背包问题算法模板(模板)强相关:[完全背包] 买书(完全背包+裸题)1. 完全背包+求方案数1021. 货币系统重点: 完全背包、求方案数和 [完全背包] 买书(完全背包+裸题) 一模一样。就注意下初始化 f[0]=1,优化到一维时,完全背包问题体积从小到大进行枚举即可。代码:#include <iostream>using namespace std;typedef long long _完全背包求具体方案
文章浏览阅读228次。一.Tomcat概述Tomcat服务器是一个免费的开放源代码的Web应用服务器,属于轻量级应用服务器,在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP程序的首选。一般来说,Tomcat虽然和Apache或者Nginx这些Web服务器一样,具有处理HTML页面的功能,然而由于其处理静态HTML的能力远不及Apache或者Nginx,所以Tomcat通常是作为一个Servlet和JSP容器,单独运行在后端。二.Tomcat核心组件1.核心组件Web 容器:完成 W_tomcat部署web项目
文章浏览阅读152次。题目描述The FZU Code Carnival is a programming competetion hosted by the ACM-ICPC Training Center of Fuzhou University. The activity mainly includes the programming contest like ACM-ICPC and strive to p..._if(winner(close),winner(close)*100,20),volstick;
文章浏览阅读129次。尊重作者劳动,转载时请标明文章出处。作者:Bugs Bunny地址:http://www.cnblogs.com/cocos2d-x/archive/2012/03/13/2393898.html在上一篇博文中我们对cocos2d-x的动作使用有了初步了解。今天,我们将通过阅读部分cocos2d-x源码来了解这个动作系统是如何运作的,以及在使用时还有什么细节需要特别注意。小弟初学cocos..._cocos2d-x 运动系统
文章浏览阅读1.7k次。vue 具名插槽用法<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> &l._vue 具名插槽使用
文章浏览阅读6.1k次,点赞16次,收藏23次。本文非常详尽地介绍了Java中的三个集合类 ArrayList,Vector与Stack”Java集合详解系列“是我在完成Java基础篇的系列博客后准备开始写的新系列。Java集合系列专栏地址:https://blog.csdn.net/column/details/21877.html之前的Java基础系列博客首发于我的个人博客:https://h2pl.github.io/在..._arraylist stack
文章浏览阅读4.8k次,点赞3次,收藏24次。本章节介绍如何在pyqt5中设置样式,让页面更加美观,如果不熟悉样式的朋友可以先看下前端样式,其实pyqt5中的样式与前端中css样式类似。参考链接一、在py文件中直接使用样式1、直接单独一个组件定义样式# 给按钮btn设置样式self.btn.setStyleSheet('background: cyan; border: none; color: #fff;')复制代码2..._pyqt5中的qss和css
文章浏览阅读6.2w次,点赞7次,收藏13次。本文记录的要实现的功能类似于 MySQL 中的 ORDER BY,上个项目中有遇到这样的一个需求。要求:从两个不同的表中获取各自的4条数据,然后整合(array_merge)成一个数组,再根据数据的创建时间降序排序取前4条。遇到这个要求的时候就不是 ORDER BY 能解决的问题了。因此翻看 PHP 手册查找到了如下方法,做此笔记。废话少说,奉上代码,清单如下:<?php/**_php 二维数组排序 按某个字段排序</div>
文章浏览阅读1.1k次。C程序一定从main()函数开始执行的(目前不考虑例外的情况)。就是一个大家遵守的规定。(被写到了C99规范),但是从开始学习C语言到现在,我们似乎看到了很多个版本的main函数,那么哪一种才是正确的呢?main函数版本main()如果浏览旧式的C代码,会发现程序以如下形式开始:#include <stdio.h>main(){ printf("hello,minger..._标准的主函数写法有没有printf
文章浏览阅读7k次。学习资料 转自浅墨_毛星云【OpenCV入门教程之三】 图像的载入,显示和输出 一站式完全解析 http://blog.csdn.net/poem_qianmo/article/details/20537737三、图像的载入和显示在新版本的OpenCV2中,最简单的图像载入和显示只需要3句代码,非常便捷。这三句代码分别对应了三个函数,他们分别是:imre__inputarray::_inputarray(const matexpr& expr)