The materialize hint forces Oracle Database to process and store the results of the query.

This can be useful if the query is expensive and you refer to it many times. For example here I'll create a function that takes one second to execute:

create or replace function f ( p int )
  return int as
begin
  dbms_lock.sleep (
    1 ) ;
  return p;
end f;
/ 

Then I'll have a three row query. This will call the function for each row. I'll join the query to itself using inline views. This will take at least 6s to process (3 rows x 2 queries = 6):

SQL> select * from (
  2     select f(rownum) v
  3     from dual connect by level <= 3
  4  ) r1 join (
  5     select f(rownum) v
  6     from dual connect by level <= 3
  7  ) r2
  8  on    r1.v = r2.v;

Elapsed: 00:00:09.32

Doing the same thing twice like this is a waste of effort. So we can put the query in the with clause. To ensure that Oracle only runs this once, I've added the materialize hint:

SQL> with rws as (
  2    select /*+ materialize */f(rownum) v
  3    from dual connect by level <= 3
  4  )
  5    select * from rws r1
  6    join  rws r2
  7    on    r1.v = r2.v;

Elapsed: 00:00:04.25

Execution Plan
----------------------------------------------------------
Plan hash value: 2390486683

---------------------------------------------------------------------
| Id  | Operation                       | Name                      |
---------------------------------------------------------------------
|   0 | SELECT STATEMENT                |                           |
|   1 |  TEMP TABLE TRANSFORMATION      |                           |
|   2 |   LOAD AS SELECT                | SYS_TEMP_0FD9D678C_E91E50 |
|   3 |    COUNT                        |                           |
|*  4 |     CONNECT BY WITHOUT FILTERING|                           |
|   5 |      FAST DUAL                  |                           |
|*  6 |   HASH JOIN                     |                           |
|   7 |    VIEW                         |                           |
|   8 |     TABLE ACCESS FULL           | SYS_TEMP_0FD9D678C_E91E50 |
|   9 |    VIEW                         |                           |
|  10 |     TABLE ACCESS FULL           | SYS_TEMP_0FD9D678C_E91E50 |
---------------------------------------------------------------------

Notice it only takes 4s vs. 9s for the original query. This is because it only executes the function 3 times instead of 6. So this can help if you have an "expensive" subquery you'll refer to multiple times in one SQL statement.

To prevent this, use the inline hint:

SQL> with rws as (
  2    select /*+ inline */f(rownum) v
  3    from dual connect by level <= 3
  4  )
  5    select * from rws r1
  6    join  rws r2
  7    on    r1.v = r2.v;

Elapsed: 00:00:10.79

Execution Plan
-----------------------------------------
Plan hash value: 155859586

-----------------------------------------
| Id  | Operation                       |
-----------------------------------------
|   0 | SELECT STATEMENT                |
|*  1 |  HASH JOIN                      |
|   2 |   VIEW                          |
|   3 |    COUNT                        |
|*  4 |     CONNECT BY WITHOUT FILTERING|
|   5 |      FAST DUAL                  |
|   6 |   VIEW                          |
|   7 |    COUNT                        |
|*  8 |     CONNECT BY WITHOUT FILTERING|
|   9 |      FAST DUAL                  |
-----------------------------------------

No temporary table and up to 10s execution time.

Note that both these hints are undocumented (though they are referred to in some support notes). Use with caution!